#include "CCurrency.h"



void __fastcall Test()
{
  {
    //inline __fastcall CCurrency();
    CCurrency CCur;  //Création à partir de rien
  }
  {
    //inline __fastcall CCurrency(int Val);
    int i;
    i = L_NS;
    CCurrency CCur(i);  //Création à partir d'un entier à L_NS
    i = 0;
    CCurrency CCur2(i);  //Création à partir d'un entier à 0
    i = 10;
    CCurrency CCur3(i);  //Création à partir d'un entier != 0
  }
  {
    //inline __fastcall CCurrency(double Val);
    int d;
    d = D_NS;
    CCurrency CCur(d);  //Création à partir d'un double à D_NS
    d = 0.0;
    CCurrency CCur2(d);  //Création à partir d'un double à 0.0
    d = 10.0;
    CCurrency CCur3(d);  //Création à partir d'un double != 0.0 entier
    d = 10.5;
    CCurrency CCur4(d);  //Création à partir d'un double != 0.0 non entier
  }
  {
    //inline __fastcall CCurrency(const Currency &Val);
    Currency c;
    CCurrency CCur(c);  //Création à partir d'un Currency à 0.0
    c = 10.0;
    CCurrency CCur2(c);  //Création à partir d'un Currency != 0.0 entier
    c = 10.5;
    CCurrency CCur3(c);  //Création à partir d'un Currency != 0.0 non entier
  }
  {
    //inline __fastcall CCurrency(const AnsiString &Val);
    AnsiString s;
    CCurrency CCur(s);  //Création à partir d'un AnsiString vide
    s = AnsiString(0);
    CCurrency CCur2(s);  //Création à partir d'un AnsiString à 0.0
    s = AnsiString(10);
    CCurrency CCur3(s);  //Création à partir d'un AnsiString != 0.0 entier
    s = AnsiString(10.5);
    CCurrency CCur4(s);  //Création à partir d'un AnsiString != 0.0 non entier
  }
  {
    //inline __fastcall CCurrency(const CCurrency &Val);
    CCurrency c;
    CCurrency CCur(c);  //Création à partir d'un CCurrency vide
    c = 0;
    CCurrency CCur2(c);  //Création à partir d'un CCurrency à 0
    c = 10;
    CCurrency CCur3(c);  //Création à partir d'un CCurrency != 0.0 entier
    c = 10.5;
    CCurrency CCur4(c);  //Création à partir d'un CCurrency != 0.0 non entier
  }
//Les accesseurs
  {
    //inline __fastcall operator int() const;
    int i;
    CCurrency CCur;
    i = CCur; ASSERT(i == L_NS);  //Initialisation d'un entier à partir d'un CCurrency vide
    CCur = 0;
    i = CCur; ASSERT(i == 0);  //Initialisation d'un entier à partir d'un CCurrency à 0
    CCur = 10;
    i = CCur; ASSERT(i == 10);  //Initialisation d'un entier à partir d'un CCurrency != 0 entier
    CCur = 10.5;
    i = CCur; ASSERT(i == 10);  //Initialisation d'un entier à partir d'un CCurrency != 0 non entier
  }
  {
    //inline __fastcall operator double() const;
    double d;
    CCurrency CCur;
    d = CCur; ASSERT(d == D_NS);  //Initialisation d'un double à partir d'un CCurrency vide
    CCur = 0;
    d = CCur; ASSERT(d == 0.0);  //Initialisation d'un double à partir d'un CCurrency à 0
    CCur = 10;
    d = CCur; ASSERT(d == 10.0);  //Initialisation d'un double à partir d'un CCurrency != 0 entier
    CCur = 10.5;
    d = CCur; ASSERT(d == 10.5);  //Initialisation d'un double à partir d'un CCurrency != 0 non entier
  }
  {
    //inline __fastcall operator Currency() const;
    Currency c;
    CCurrency CCur;
    c = Currency(CCur); ASSERT(c == 0.0);  //Initialisation d'un Currency à partir d'un CCurrency vide
    CCur = 0;
    c = Currency(CCur); ASSERT(c == 0.0);  //Initialisation d'un Currency à partir d'un CCurrency à 0
    CCur = 10;
    c = Currency(CCur); ASSERT(c == 10.0);  //Initialisation d'un Currency à partir d'un CCurrency != 0 entier
    CCur = 10.5;
    c = Currency(CCur); ASSERT(c == 10.5);  //Initialisation d'un Currency à partir d'un CCurrency != 0 non entier
  }
  {
    //inline __fastcall operator AnsiString() const;
    AnsiString s;
    CCurrency CCur;
    s = CCur; ASSERT(s.IsEmpty());  //Initialisation d'un AnsiString à partir d'un CCurrency vide
    CCur = 0;
    s = CCur; ASSERT(s == "0");  //Initialisation d'un AnsiString à partir d'un CCurrency à 0
    CCur = 10;
    s = CCur; ASSERT(s == "10");  //Initialisation d'un AnsiString à partir d'un CCurrency != 0 entier
    CCur = 10.5;
    s = CCur; ASSERT(s == "10.5");  //Initialisation d'un AnsiString à partir d'un CCurrency != 0 non entier
  }
  {
    //__property AnsiString SQL = {read = GetSQL};
    AnsiString s;
    CCurrency CCur;
    s = CCur.SQL; ASSERT(s == "NULL");  //Retour de la propriété SQL à partir d'un CCurrency vide
    CCur = 0;
    s = CCur.SQL; ASSERT(s == "0");  //Retour de la propriété SQL à partir d'un CCurrency à 0
    CCur = 10;
    s = CCur.SQL; ASSERT(s == "10");  //Retour de la propriété SQL à partir d'un CCurrency != 0 entier
    CCur = 10.5;
    s = CCur.SQL; ASSERT(s == "10.5");  //Retour de la propriété SQL à partir d'un CCurrency != 0 non entier
  }
  {
    //__property AnsiString Text = {read = GetText};
    AnsiString s;
    CCurrency CCur;
    s = CCur.Text; ASSERT(s.IsEmpty());  //Retour de la propriété Text à partir d'un CCurrency vide
    CCur = 0;
    s = CCur.Text; ASSERT(s == "0");  //Retour de la propriété Text à partir d'un CCurrency à 0
    CCur = 10;
    s = CCur.Text; ASSERT(s == "10");  //Retour de la propriété Text à partir d'un CCurrency != 0 entier
    CCur = 10.5;
    s = CCur.Text; ASSERT(s == "10.5");  //Retour de la propriété Text à partir d'un CCurrency != 0 non entier
  }
  {
    //inline __fastcall operator AnsiString() const;
    AnsiString s;
    CCurrency CCur;
    s = AnsiString(CCur); ASSERT(s.IsEmpty());  //Initialisation d'un AnsiString à partir d'un CCurrency vide
    CCur = 0;
    s = AnsiString(CCur); ASSERT(s == "0");  //Initialisation d'un AnsiString à partir d'un CCurrency à 0
    CCur = 10;
    s = AnsiString(CCur); ASSERT(s == "10");  //Initialisation d'un AnsiString à partir d'un CCurrency != 0 entier
    CCur = 10.5;
    s = AnsiString(CCur); ASSERT(s == "10.5");  //Initialisation d'un AnsiString à partir d'un CCurrency != 0 non entier
  }
  {
    //inline void __fastcall Clear();
    double d;
    CCurrency CCur;
    d = CCur; ASSERT(d == D_NS);
    CCur.Clear(); d = CCur; ASSERT(d == D_NS);  //Remise à vide d'un CCurrency vide
    CCur = 0;
    d = CCur; ASSERT(d == 0.0);
    CCur.Clear(); d = CCur; ASSERT(d == D_NS);  //Remise à vide d'un CCurrency à 0
    CCur = 10;
    d = CCur; ASSERT(d == 10.0);
    CCur.Clear(); d = CCur; ASSERT(d == D_NS);  //Remise à vide d'un CCurrency != 0 entier
    CCur = 10.5;
    d = CCur; ASSERT(d == 10.5);
    CCur.Clear(); d = CCur; ASSERT(d == D_NS);  //Remise à vide d'un CCurrency != 0 non entier
  }
  {
    //inline bool __fastcall IsEmpty() const;
    CCurrency CCur;
    ASSERT(CCur.IsEmpty());  //Test d'un CCurrency vide
    CCur = 0;
    ASSERT(!CCur.IsEmpty());  //Test d'un CCurrency à 0
    CCur = 10;
    ASSERT(!CCur.IsEmpty());  //Test d'un CCurrency != 0 entier
    CCur = 10.5;
    ASSERT(!CCur.IsEmpty());  //Test d'un CCurrency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator =(int Val);
    int i;
    CCurrency CCur;
    i = L_NS;
    CCur = i; ASSERT(CCur.IsEmpty());  //Affectation d'un CCurrency à partir d'un entier à L_NS
    i = 0;
    CCur = i; ASSERT(!CCur.IsEmpty());  //Affectation d'un CCurrency à partir d'un entier à 0
    i = 10;
    CCur = i; ASSERT(!CCur.IsEmpty());  //Affectation d'un CCurrency à partir d'un entier != 0
  }
  {
    //inline CCurrency & __fastcall operator =(double Val);
    double d;
    CCurrency CCur;
    d = D_NS;
    CCur = d; ASSERT(CCur.IsEmpty());  //Affectation d'un CCurrency à partir d'un double à D_NS
    d = 0.0;
    CCur = d; ASSERT(!CCur.IsEmpty());  //Affectation d'un CCurrency à partir d'un double à 0.0
    d = 10.0;
    CCur = d; ASSERT(!CCur.IsEmpty());  //Affectation d'un CCurrency à partir d'un double != 0.0 entier
    d = 10.5;
    CCur = d; ASSERT(!CCur.IsEmpty());  //Affectation d'un CCurrency à partir d'un double != 0.0 non entier
  }
  {
    //inline CCurrency & __fastcall operator =(const AnsiString &Val);
    AnsiString s;
    CCurrency CCur;
    CCur = s; ASSERT(CCur.IsEmpty());  //Affectation d'un CCurrency à partir d'un AnsiString vide
    s = "0";
    CCur = s; ASSERT(CCur == 0);  //Affectation d'un CCurrency à partir d'un AnsiString avec "0"
    s = "10";
    CCur = s; ASSERT(CCur == 10);  //Affectation d'un CCurrency à partir d'un AnsiString avec "10"
    s = AnsiString(10.5);
    CCur = s; ASSERT(CCur == 10.5);  //Affectation d'un CCurrency à partir d'un AnsiString avec "10.5"
  }
  {
    //inline CCurrency & __fastcall operator =(const Currency &Val);
    Currency c;
    CCurrency CCur;
    CCur = c; ASSERT(CCur == 0);  //Affectation d'un CCurrency à partir d'un Currency à 0
    c = 10;
    CCur = c; ASSERT(CCur == 10);  //Affectation d'un CCurrency à partir d'un Currency != 0 entier
    c = 10.5;
    CCur = c; ASSERT(CCur == 10.5);  //Affectation d'un CCurrency à partir d'un Currency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator =(const CCurrency &Val);
    CCurrency CCur,c;
    CCur = c; ASSERT(CCur.IsEmpty());  //Affectation d'un CCurrency à partir d'un CCurrency vide
    c = 0;
    CCur = c; ASSERT(CCur == 0);  //Affectation d'un CCurrency à partir d'un CCurrency à 0
    c = 10;
    CCur = c; ASSERT(CCur == 10);  //Affectation d'un CCurrency à partir d'un CCurrency != 0 entier
    c = 10.5;
    CCur = c; ASSERT(CCur == 10.5);  //Affectation d'un CCurrency à partir d'un CCurrency != 0 non entier
  }
  {
    //inline bool __fastcall operator ==(int Val) const;
    int i;
    CCurrency CCur;
    i = L_NS;
    if (!(CCur == i))  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur == i)  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur == i)  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (CCur == i)  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur == i))  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur == i)  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (CCur == i)  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur == i)  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur == i))  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (CCur == i)  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur == i)  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur == i)  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator ==(double Val) const;
    double d;
    CCurrency CCur;
    d = D_NS;
    if (!(CCur == d))  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (CCur == d)  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (CCur == d)  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur == d)  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (CCur == d)  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (!(CCur == d))  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (CCur == d)  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur == d)  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (CCur == d)  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (CCur == d)  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (!(CCur == d))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur == d)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (CCur == d)  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (CCur == d)  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (CCur == d)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur == d))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator ==(const Currency &Val) const;
    Currency c;
    CCurrency CCur;
    if (!(CCur == c))  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (CCur == c)  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur == c)  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0.0;
    if (!(CCur == c))  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (CCur == c)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur == c)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0.0;
    if (CCur == c)  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (!(CCur == c))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur == c)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0.0;
    if (CCur == c)  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (CCur == c)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur == c))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator ==(const CCurrency &Val) const;
    CCurrency CCur,c;
    if (!(CCur == c))  //Comparaison d'un CCurrency vide avec un CCurrency vide
      ASSERT(false);
    c = 0.0;
    if (CCur == c)  //Comparaison d'un CCurrency vide avec un CCurrency à 0
      ASSERT(false);
    c = 10.0;
    if (CCur == c)  //Comparaison d'un CCurrency vide avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur == c)  //Comparaison d'un CCurrency vide avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c.Clear();
    if (CCur == c)  //Comparaison d'un CCurrency à 0 avec un CCurrency vide
      ASSERT(false);
    c = 0.0;
    if (!(CCur == c))  //Comparaison d'un CCurrency à 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10.0;
    if (CCur == c)  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur == c)  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c.Clear();
    if (CCur == c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0.0;
    if (CCur == c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10.0;
    if (!(CCur == c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur == c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c.Clear();
    if (CCur == c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0.0;
    if (CCur == c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10.0;
    if (CCur == c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur == c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator ==(int ValL,const CCurrency &ValC);
    int i;
    CCurrency CCur;
    i = L_NS;
    if (!(i == CCur))  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i == CCur)  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i == CCur)  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (i == CCur)  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i == CCur))  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i == CCur)  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (i == CCur)  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i == CCur)  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i == CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (i == CCur)  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i == CCur)  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i == CCur)  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator ==(double ValD,const CCurrency &ValC);
    double d;
    CCurrency CCur;
    d = D_NS;
    if (!(d == CCur))  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (d == CCur)  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (d == CCur)  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d == CCur)  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (d == CCur)  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (!(d == CCur))  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (d == CCur)  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d == CCur)  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (d == CCur)  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (d == CCur)  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (!(d == CCur))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d == CCur)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (d == CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (d == CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (d == CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d == CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator ==(const Currency &Val,const CCurrency &ValC);
    Currency c;
    CCurrency CCur;
    if (!(c == CCur))  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (c == CCur)  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c == CCur)  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0.0;
    if (!(c == CCur))  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (c == CCur)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c == CCur)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0.0;
    if (c == CCur)  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (!(c == CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c == CCur)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0.0;
    if (c == CCur)  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (c == CCur)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c == CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator !=(int Val) const;
    int i;
    CCurrency CCur;
    i = L_NS;
    if (CCur != i)  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur != i))  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur != i))  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (!(CCur != i))  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur != i)  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur != i))  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (!(CCur != i))  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur != i))  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur != i)  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (!(CCur != i))  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur != i))  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur != i))  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator !=(double Val) const;
    double d;
    CCurrency CCur;
    d = D_NS;
    if (CCur != d)  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (!(CCur != d))  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (!(CCur != d))  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur != d))  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (!(CCur != d))  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (CCur != d)  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (!(CCur != d))  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur != d))  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (!(CCur != d))  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (!(CCur != d))  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (CCur != d)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur != d))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (!(CCur != d))  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (!(CCur != d))  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (!(CCur != d))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur != d)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator !=(const Currency &Val) const;
    Currency c;
    CCurrency CCur;
    if (CCur != c)  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur != c))  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0.0;
    if (CCur != c)  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur != c))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (CCur != c)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur != c))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur != c)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator !=(const CCurrency &Val) const;
    CCurrency CCur,c;
    if (CCur != c)  //Comparaison d'un CCurrency vide avec un CCurrency vide
      ASSERT(false);
    c = 0.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency vide avec un CCurrency à 0
      ASSERT(false);
    c = 10.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency vide avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur != c))  //Comparaison d'un CCurrency vide avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c.Clear();
    if (!(CCur != c))  //Comparaison d'un CCurrency à 0 avec un CCurrency vide
      ASSERT(false);
    c = 0.0;
    if (CCur != c)  //Comparaison d'un CCurrency à 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur != c))  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c.Clear();
    if (!(CCur != c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10.0;
    if (CCur != c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur != c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c.Clear();
    if (!(CCur != c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10.0;
    if (!(CCur != c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur != c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator !=(int ValL,const CCurrency &ValC);
    int i;
    CCurrency CCur;
    i = L_NS;
    if (i != CCur)  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i != CCur))  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i != CCur))  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (!(i != CCur))  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i != CCur)  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i != CCur))  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (!(i != CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i != CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i != CCur)  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (!(i != CCur))  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i != CCur))  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i != CCur))  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator !=(double ValD,const CCurrency &ValC);
    double d;
    CCurrency CCur;
    d = D_NS;
    if (d != CCur)  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (!(d != CCur))  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (!(d != CCur))  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d != CCur))  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (!(d != CCur))  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (d != CCur)  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (!(d != CCur))  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d != CCur))  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (!(d != CCur))  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (!(d != CCur))  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (d != CCur)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d != CCur))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (!(d != CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0.0;
    if (!(d != CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10.0;
    if (!(d != CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d != CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator !=(const Currency &Val,const CCurrency &ValC);
    Currency c;
    CCurrency CCur;
    if (c != CCur)  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (!(c != CCur))  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c != CCur))  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0.0;
    if (c != CCur)  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (!(c != CCur))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c != CCur))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0.0;
    if (!(c != CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (c != CCur)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c != CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0.0;
    if (!(c != CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10.0;
    if (!(c != CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c != CCur)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator <(int Val) const;
    int i;
    CCurrency CCur;
    i = L_NS;
    if (CCur < i)  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur < i)  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur < i))  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (CCur < i)  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur < i)  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur < i))  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (CCur < i)  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur < i)  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur < i)  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (CCur < i)  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur < i)  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur < i)  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator <(double Val) const;
    double d;
    CCurrency CCur;
    d = D_NS;
    if (CCur < d)  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (CCur < d)  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(CCur < d))  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur < d))  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (CCur < d)  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (CCur < d)  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(CCur < d))  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur < d))  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (CCur < d)  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (CCur < d)  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (CCur < d)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur < d))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (CCur < d)  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (CCur < d)  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (CCur < d)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur < d)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator <(Currency Val) const;
    Currency c;
    CCurrency CCur;
    c = 0;
    if (CCur < c)  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur < c))  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur < c))  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0;
    if (CCur < c)  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur < c))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur < c))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0;
    if (CCur < c)  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (CCur < c)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur < c))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0;
    if (CCur < c)  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (CCur < c)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur < c)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator <(CCurrency Val) const;
    CCurrency CCur,c;
    if (CCur < c)  //Comparaison d'un CCurrency vide avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (CCur < c)  //Comparaison d'un CCurrency vide avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur < c))  //Comparaison d'un CCurrency vide avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur < c))  //Comparaison d'un CCurrency vide avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c.Clear();
    if (CCur < c)  //Comparaison d'un CCurrency à 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (CCur < c)  //Comparaison d'un CCurrency à 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur < c))  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur < c))  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c.Clear();
    if (CCur < c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (CCur < c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (CCur < c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur < c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c.Clear();
    if (CCur < c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (CCur < c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (CCur < c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur < c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator <(int ValL,const CCurrency &ValC);
    int i;
    CCurrency CCur;
    i = L_NS;
    if (!(i < CCur))  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i < CCur))  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i < CCur)  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (!(i < CCur))  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i < CCur))  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i < CCur)  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (!(i < CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i < CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i < CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (!(i < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator <(double ValD,const CCurrency &ValC);
    double d;
    CCurrency CCur;
    d = D_NS;
    if (!(d < CCur))  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d < CCur))  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10;
    if (d < CCur)  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d < CCur)  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (!(d < CCur))  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d < CCur))  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (d < CCur)  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d < CCur)  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (!(d < CCur))  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d < CCur))  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(d < CCur))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d < CCur)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (!(d < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(d < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator <(const Currency &Val,const CCurrency &ValC);
    Currency c;
    CCurrency CCur;
    c = 0;
    if (!(c < CCur))  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (c < CCur)  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c < CCur)  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0;
    if (!(c < CCur))  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (c < CCur)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c < CCur)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0;
    if (!(c < CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(c < CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c < CCur)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0;
    if (!(c < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(c < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c < CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator <=(int Val) const;
    int i;
    CCurrency CCur;
    i = L_NS;
    if (!(CCur <= i))  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur <= i))  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur <= i))  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (!(CCur <= i))  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur <= i))  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur <= i))  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (CCur <= i)  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur <= i)  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur <= i))  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (CCur <= i)  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur <= i)  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur <= i)  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator <=(double Val) const;
    double d;
    CCurrency CCur;
    d = D_NS;
    if (!(CCur <= d))  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(CCur <= d))  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(CCur <= d))  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur <= d))  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (!(CCur <= d))  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(CCur <= d))  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(CCur <= d))  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur <= d))  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (CCur <= d)  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (CCur <= d)  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(CCur <= d))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur <= d))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (CCur <= d)  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (CCur <= d)  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (CCur <= d)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur <= d))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator <=(Currency Val) const;
    Currency c;
    CCurrency CCur;
    c = 0;
    if (!(CCur <= c))  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur <= c))  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur <= c))  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0;
    if (!(CCur <= c))  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur <= c))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur <= c))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0;
    if (CCur <= c)  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur <= c))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur <= c))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0;
    if (CCur <= c)  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (CCur <= c)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur <= c))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator <=(CCurrency Val) const;
    CCurrency CCur,c;
    if (!(CCur <= c))  //Comparaison d'un CCurrency vide avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (!(CCur <= c))  //Comparaison d'un CCurrency vide avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur <= c))  //Comparaison d'un CCurrency vide avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur <= c))  //Comparaison d'un CCurrency vide avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c.Clear();
    if (!(CCur <= c))  //Comparaison d'un CCurrency à 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (!(CCur <= c))  //Comparaison d'un CCurrency à 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur <= c))  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur <= c))  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c.Clear();
    if (CCur <= c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (CCur <= c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur <= c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur <= c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c.Clear();
    if (CCur <= c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (CCur <= c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (CCur <= c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur <= c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator <=(int ValL,const CCurrency &ValC);
    int i;
    CCurrency CCur;
    i = L_NS;
    if (!(i <= CCur))  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i <= CCur))  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i <= CCur)  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (!(i <= CCur))  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i <= CCur))  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i <= CCur)  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (!(i <= CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i <= CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i <= CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (!(i <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator <=(double ValD,const CCurrency &ValC);
    double d;
    CCurrency CCur;
    d = D_NS;
    if (!(d <= CCur))  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d <= CCur))  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10;
    if (d <= CCur)  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d <= CCur)  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (!(d <= CCur))  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d <= CCur))  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (d <= CCur)  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d <= CCur)  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (!(d <= CCur))  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d <= CCur))  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(d <= CCur))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d <= CCur)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (!(d <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(d <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator <=(const Currency &Val,const CCurrency &ValC);
    Currency c;
    CCurrency CCur;
    c = 0;
    if (!(c <= CCur))  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (c <= CCur)  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c <= CCur)  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0;
    if (!(c <= CCur))  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (c <= CCur)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c <= CCur)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0;
    if (!(c <= CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(c <= CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c <= CCur)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0;
    if (!(c <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(c <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c <= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator >(int Val) const;
    int i;
    CCurrency CCur;
    i = L_NS;
    if (CCur > i)  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur > i)  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur > i)  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (CCur > i)  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (CCur > i)  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur > i)  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (!(CCur > i))  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur > i))  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur > i)  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (!(CCur > i))  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur > i))  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur > i))  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator >(double Val) const;
    double d;
    CCurrency CCur;
    d = D_NS;
    if (CCur > d)  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (CCur > d)  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10;
    if (CCur > d)  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur > d)  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (CCur > d)  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (CCur > d)  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (CCur > d)  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur > d)  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (!(CCur > d))  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(CCur > d))  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (CCur > d)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur > d)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (!(CCur > d))  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(CCur > d))  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(CCur > d))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur > d)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator >(Currency Val) const;
    Currency c;
    CCurrency CCur;
    c = 0;
    if (CCur > c)  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (CCur > c)  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur > c)  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0;
    if (CCur > c)  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (CCur > c)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur > c)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0;
    if (!(CCur > c))  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (CCur > c)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur > c)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0;
    if (!(CCur > c))  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur > c))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur > c)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator >(CCurrency Val) const;
    CCurrency CCur,c;
    if (CCur > c)  //Comparaison d'un CCurrency vide avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (CCur > c)  //Comparaison d'un CCurrency vide avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (CCur > c)  //Comparaison d'un CCurrency vide avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur > c)  //Comparaison d'un CCurrency vide avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c.Clear();
    if (CCur > c)  //Comparaison d'un CCurrency à 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (CCur > c)  //Comparaison d'un CCurrency à 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (CCur > c)  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur > c)  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c.Clear();
    if (!(CCur > c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (!(CCur > c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (CCur > c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur > c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c.Clear();
    if (!(CCur > c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (!(CCur > c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur > c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur > c)  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator >(int ValL,const CCurrency &ValC);
    int i;
    CCurrency CCur;
    i = L_NS;
    if (i > CCur)  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i > CCur)  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i > CCur))  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (i > CCur)  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i > CCur)  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i > CCur))  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (i > CCur)  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i > CCur)  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i > CCur)  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (i > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator >(double ValD,const CCurrency &ValC);
    double d;
    CCurrency CCur;
    d = D_NS;
    if (d > CCur)  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (d > CCur)  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(d > CCur))  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d > CCur))  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (d > CCur)  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (d > CCur)  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(d > CCur))  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d > CCur))  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (d > CCur)  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (d > CCur)  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (d > CCur)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d > CCur))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (d > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (d > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (d > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (d > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator >(const Currency &Val,const CCurrency &ValC);
    Currency c;
    CCurrency CCur;
    c = 0;
    if (c > CCur)  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(c > CCur))  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c > CCur))  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0;
    if (c > CCur)  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(c > CCur))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c > CCur))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0;
    if (c > CCur)  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (c > CCur)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c > CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0;
    if (c > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (c > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (c > CCur)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator >=(int Val) const;
    int i;
    CCurrency CCur;
    i = L_NS;
    if (!(CCur >= i))  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur >= i))  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur >= i)  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (!(CCur >= i))  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur >= i))  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (CCur >= i)  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (!(CCur >= i))  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur >= i))  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur >= i))  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (!(CCur >= i))  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(CCur >= i))  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(CCur >= i))  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator >=(double Val) const;
    double d;
    CCurrency CCur;
    d = D_NS;
    if (!(CCur >= d))  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(CCur >= d))  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10;
    if (CCur >= d)  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur >= d)  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (!(CCur >= d))  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(CCur >= d))  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (CCur >= d)  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur >= d)  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (!(CCur >= d))  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(CCur >= d))  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(CCur >= d))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (CCur >= d)  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (!(CCur >= d))  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(CCur >= d))  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(CCur >= d))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(CCur >= d))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator >=(Currency Val) const;
    Currency c;
    CCurrency CCur;
    c = 0;
    if (!(CCur >= c))  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (CCur >= c)  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur >= c)  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0;
    if (!(CCur >= c))  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (CCur >= c)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur >= c)  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0;
    if (!(CCur >= c))  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur >= c))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur >= c)  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0;
    if (!(CCur >= c))  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur >= c))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur >= c))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline bool __fastcall operator >=(CCurrency Val) const;
    CCurrency CCur,c;
    if (!(CCur >= c))  //Comparaison d'un CCurrency vide avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (!(CCur >= c))  //Comparaison d'un CCurrency vide avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (CCur >= c)  //Comparaison d'un CCurrency vide avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur >= c)  //Comparaison d'un CCurrency vide avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c.Clear();
    if (!(CCur >= c))  //Comparaison d'un CCurrency à 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (!(CCur >= c))  //Comparaison d'un CCurrency à 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (CCur >= c)  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur >= c)  //Comparaison d'un CCurrency à 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c.Clear();
    if (!(CCur >= c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (!(CCur >= c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur >= c))  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (CCur >= c)  //Comparaison d'un CCurrency entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c.Clear();
    if (!(CCur >= c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency vide
      ASSERT(false);
    c = 0;
    if (!(CCur >= c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency à 0
      ASSERT(false);
    c = 10;
    if (!(CCur >= c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(CCur >= c))  //Comparaison d'un CCurrency non entier != 0 avec un CCurrency != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator >=(int ValL,const CCurrency &ValC);
    int i;
    CCurrency CCur;
    i = L_NS;
    if (!(i >= CCur))  //Comparaison d'un CCurrency vide avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i >= CCur))  //Comparaison d'un CCurrency vide avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i >= CCur))  //Comparaison d'un CCurrency vide avec un entier != 0
      ASSERT(false);
    CCur = 0;
    i = L_NS;
    if (!(i >= CCur))  //Comparaison d'un CCurrency à 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (!(i >= CCur))  //Comparaison d'un CCurrency à 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i >= CCur))  //Comparaison d'un CCurrency à 0 avec un entier != 0
      ASSERT(false);
    CCur = 10;
    i = L_NS;
    if (i >= CCur)  //Comparaison d'un CCurrency entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i >= CCur)  //Comparaison d'un CCurrency entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (!(i >= CCur))  //Comparaison d'un CCurrency entier != 0 avec un entier != 0
      ASSERT(false);
    CCur = 10.5;
    i = L_NS;
    if (i >= CCur)  //Comparaison d'un CCurrency non entier != 0 avec un entier à L_NS
      ASSERT(false);
    i = 0;
    if (i >= CCur)  //Comparaison d'un CCurrency non entier != 0 avec un entier à 0
      ASSERT(false);
    i = 10;
    if (i >= CCur)  //Comparaison d'un CCurrency non entier != 0 avec un entier != 0
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator >=(double ValD,const CCurrency &ValC);
    double d;
    CCurrency CCur;
    d = D_NS;
    if (!(d >= CCur))  //Comparaison d'un CCurrency vide avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d >= CCur))  //Comparaison d'un CCurrency vide avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(d >= CCur))  //Comparaison d'un CCurrency vide avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d >= CCur))  //Comparaison d'un CCurrency vide avec un double != 0 non entier
      ASSERT(false);
    CCur = 0;
    d = D_NS;
    if (!(d >= CCur))  //Comparaison d'un CCurrency à 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (!(d >= CCur))  //Comparaison d'un CCurrency à 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(d >= CCur))  //Comparaison d'un CCurrency à 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d >= CCur))  //Comparaison d'un CCurrency à 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10;
    d = D_NS;
    if (d >= CCur)  //Comparaison d'un CCurrency entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (d >= CCur)  //Comparaison d'un CCurrency entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (!(d >= CCur))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d >= CCur))  //Comparaison d'un CCurrency entier != 0 avec un double != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    d = D_NS;
    if (d >= CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double à D_NS
      ASSERT(false);
    d = 0;
    if (d >= CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double à 0
      ASSERT(false);
    d = 10;
    if (d >= CCur)  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 entier
      ASSERT(false);
    d = 10.5;
    if (!(d >= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un double != 0 non entier
      ASSERT(false);
  }
  {
    //inline friend bool __fastcall operator >=(const Currency &Val,const CCurrency &ValC);
    Currency c;
    CCurrency CCur;
    c = 0;
    if (!(c >= CCur))  //Comparaison d'un CCurrency vide avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(c >= CCur))  //Comparaison d'un CCurrency vide avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c >= CCur))  //Comparaison d'un CCurrency vide avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 0;
    c = 0;
    if (!(c >= CCur))  //Comparaison d'un CCurrency à 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(c >= CCur))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c >= CCur))  //Comparaison d'un CCurrency à 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10;
    c = 0;
    if (c >= CCur)  //Comparaison d'un CCurrency entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (!(c >= CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c >= CCur))  //Comparaison d'un CCurrency entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
    CCur = 10.5;
    c = 0;
    if (c >= CCur)  //Comparaison d'un CCurrency non entier != 0 avec un Currency à 0
      ASSERT(false);
    c = 10;
    if (c >= CCur)  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 entier
      ASSERT(false);
    c = 10.5;
    if (!(c >= CCur))  //Comparaison d'un CCurrency non entier != 0 avec un Currency != 0 non entier
      ASSERT(false);
  }
  {
    //inline CCurrency __fastcall operator +(int Val) const;
    int i;
    CCurrency CCur,r;
    i = L_NS;
    r = CCur + i; ASSERT(r.IsEmpty());  //Ajout d'un CCurrency vide et d'un entier à L_NS
    i = 0;
    r = CCur + i; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency vide et d'un entier à 0
    i = 10;
    r = CCur + i; ASSERT(r == 10.0);  //Ajout d'un CCurrency vide et d'un entier != 0
    CCur = 0;
    i = L_NS;
    r = CCur + i; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un entier à L_NS
    i = 0;
    r = CCur + i; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un entier à 0
    i = 10;
    r = CCur + i; ASSERT(r == 10.0);  //Ajout d'un CCurrency à 0 et d'un entier != 0
    CCur = 10;
    i = L_NS;
    r = CCur + i; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un entier à L_NS
    i = 0;
    r = CCur + i; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un entier à 0
    i = 10;
    r = CCur + i; ASSERT(r == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un entier != 0
    CCur = 10.5;
    i = L_NS;
    r = CCur + i; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un entier à L_NS
    i = 0;
    r = CCur + i; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un entier à 0
    i = 10;
    r = CCur + i; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un entier != 0
  }
  {
    //inline CCurrency __fastcall operator +(double Val) const;
    double d;
    CCurrency CCur,r;
    d = D_NS;
    r = CCur + d; ASSERT(r.IsEmpty());  //Ajout d'un CCurrency vide et d'un double à D_NS
    d = 0;
    r = CCur + d; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency vide et d'un double à 0
    d = 10;
    r = CCur + d; ASSERT(r == 10.0);  //Ajout d'un CCurrency vide et d'un double != 0 entier
    d = 10.5;
    r = CCur + d; ASSERT(r == 10.5);  //Ajout d'un CCurrency vide et d'un double != 0 non entier
    CCur = 0;
    d = D_NS;
    r = CCur + d; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un double à D_NS
    d = 0;
    r = CCur + d; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un double à 0
    d = 10;
    r = CCur + d; ASSERT(r == 10.0);  //Ajout d'un CCurrency à 0 et d'un double != 0 entier
    d = 10.5;
    r = CCur + d; ASSERT(r == 10.5);  //Ajout d'un CCurrency à 0 et d'un double != 0 non entier
    CCur = 10;
    d = D_NS;
    r = CCur + d; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un double à D_NS
    d = 0;
    r = CCur + d; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un double à 0
    d = 10;
    r = CCur + d; ASSERT(r == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un double != 0 entier
    d = 10.5;
    r = CCur + d; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 entier et d'un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    r = CCur + d; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un double à D_NS
    d = 0;
    r = CCur + d; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un double à 0
    d = 10;
    r = CCur + d; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un double != 0 entier
    d = 10.5;
    r = CCur + d; ASSERT(r == 21.0);  //Ajout d'un CCurrency != 0 non entier et d'un double != 0 non entier
  }
  {
    //inline CCurrency __fastcall operator +(const Currency &Val) const;
    Currency c;
    CCurrency CCur,r;
    c = 0;
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency vide et d'un Currency à 0
    c = 10;
    r = CCur + c; ASSERT(r == 10.0);  //Ajout d'un CCurrency vide et d'un Currency != 0 entier
    c = 10.5;
    r = CCur + c; ASSERT(r == 10.5);  //Ajout d'un CCurrency vide et d'un Currency != 0 non entier
    CCur = 0;
    c = 0;
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un Currency à 0
    c = 10;
    r = CCur + c; ASSERT(r == 10.0);  //Ajout d'un CCurrency à 0 et d'un Currency != 0 entier
    c = 10.5;
    r = CCur + c; ASSERT(r == 10.5);  //Ajout d'un CCurrency à 0 et d'un Currency != 0 non entier
    CCur = 10;
    c = 0;
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un Currency à 0
    c = 10;
    r = CCur + c; ASSERT(r == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un Currency != 0 entier
    c = 10.5;
    r = CCur + c; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 entier et d'un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un Currency à 0
    c = 10;
    r = CCur + c; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un Currency != 0 entier
    c = 10.5;
    r = CCur + c; ASSERT(r == 21.0);  //Ajout d'un CCurrency != 0 non entier et d'un Currency != 0 non entier
  }
  {
    //inline CCurrency __fastcall operator +(const CCurrency &Val) const;
    CCurrency CCur,c,r;
    r = CCur + c; ASSERT(r.IsEmpty());  //Ajout d'un CCurrency vide et d'un CCurrency vide
    c = 0;
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency vide et d'un CCurrency à 0
    c = 10;
    r = CCur + c; ASSERT(r == 10.0);  //Ajout d'un CCurrency vide et d'un CCurrency != 0 entier
    c = 10.5;
    r = CCur + c; ASSERT(r == 10.5);  //Ajout d'un CCurrency vide et d'un CCurrency != 0 non entier
    CCur = 0;
    c.Clear();
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un CCurrency vide
    c = 0;
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un CCurrency à 0
    c = 10;
    r = CCur + c; ASSERT(r == 10.0);  //Ajout d'un CCurrency à 0 et d'un CCurrency != 0 entier
    c = 10.5;
    r = CCur + c; ASSERT(r == 10.5);  //Ajout d'un CCurrency à 0 et d'un CCurrency != 0 non entier
    CCur = 10;
    c.Clear();
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un CCurrency vide
    c = 0;
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un CCurrency à 0
    c = 10;
    r = CCur + c; ASSERT(r == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un CCurrency != 0 entier
    c = 10.5;
    r = CCur + c; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 entier et d'un CCurrency != 0 non entier
    CCur = 10.5;
    c.Clear();
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un CCurrency vide
    c = 0;
    r = CCur + c; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un CCurrency à 0
    c = 10;
    r = CCur + c; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un CCurrency != 0 entier
    c = 10.5;
    r = CCur + c; ASSERT(r == 21.0);  //Ajout d'un CCurrency != 0 non entier et d'un CCurrency != 0 non entier
  }
  {
    //inline friend CCurrency __fastcall operator +(int ValL,const CCurrency &ValC);
    int i;
    CCurrency CCur,r;
    i = L_NS;
    r = i + CCur; ASSERT(r.IsEmpty());  //Ajout d'un CCurrency vide et d'un entier à L_NS
    i = 0;
    r = i + CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency vide et d'un entier à 0
    i = 10;
    r = i + CCur; ASSERT(r == 10.0);  //Ajout d'un CCurrency vide et d'un entier != 0
    CCur = 0;
    i = L_NS;
    r = i + CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un entier à L_NS
    i = 0;
    r = i + CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un entier à 0
    i = 10;
    r = i + CCur; ASSERT(r == 10.0);  //Ajout d'un CCurrency à 0 et d'un entier != 0
    CCur = 10;
    i = L_NS;
    r = i + CCur; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un entier à L_NS
    i = 0;
    r = i + CCur; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un entier à 0
    i = 10;
    r = i + CCur; ASSERT(r == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un entier != 0
    CCur = 10.5;
    i = L_NS;
    r = i + CCur; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un entier à L_NS
    i = 0;
    r = i + CCur; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un entier à 0
    i = 10;
    r = i + CCur; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un entier != 0
  }
  {
    //inline friend CCurrency __fastcall operator +(double ValD,const CCurrency &ValC);
    double d;
    CCurrency CCur,r;
    d = D_NS;
    r = d + CCur; ASSERT(r.IsEmpty());  //Ajout d'un CCurrency vide et d'un double à D_NS
    d = 0;
    r = d + CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency vide et d'un double à 0
    d = 10;
    r = d + CCur; ASSERT(r == 10.0);  //Ajout d'un CCurrency vide et d'un double != 0 entier
    d = 10.5;
    r = d + CCur; ASSERT(r == 10.5);  //Ajout d'un CCurrency vide et d'un double != 0 non entier
    CCur = 0;
    d = D_NS;
    r = d + CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un double à D_NS
    d = 0;
    r = d + CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un double à 0
    d = 10;
    r = d + CCur; ASSERT(r == 10.0);  //Ajout d'un CCurrency à 0 et d'un double != 0 entier
    d = 10.5;
    r = d + CCur; ASSERT(r == 10.5);  //Ajout d'un CCurrency à 0 et d'un double != 0 non entier
    CCur = 10;
    d = D_NS;
    r = d + CCur; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un double à D_NS
    d = 0;
    r = d + CCur; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un double à 0
    d = 10;
    r = d + CCur; ASSERT(r == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un double != 0 entier
    d = 10.5;
    r = d + CCur; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 entier et d'un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    r = d + CCur; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un double à D_NS
    d = 0;
    r = d + CCur; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un double à 0
    d = 10;
    r = d + CCur; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un double != 0 entier
    d = 10.5;
    r = d + CCur; ASSERT(r == 21.0);  //Ajout d'un CCurrency != 0 non entier et d'un double != 0 non entier
  }
  {
    //inline friend CCurrency __fastcall operator +(const Currency &Val,const CCurrency &ValC);
    Currency c;
    CCurrency CCur,r;
    c = 0;
    r = c + CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency vide et d'un Currency à 0
    c = 10;
    r = c + CCur; ASSERT(r == 10.0);  //Ajout d'un CCurrency vide et d'un Currency != 0 entier
    c = 10.5;
    r = c + CCur; ASSERT(r == 10.5);  //Ajout d'un CCurrency vide et d'un Currency != 0 non entier
    CCur = 0;
    c = 0;
    r = c + CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Ajout d'un CCurrency à 0 et d'un Currency à 0
    c = 10;
    r = c + CCur; ASSERT(r == 10.0);  //Ajout d'un CCurrency à 0 et d'un Currency != 0 entier
    c = 10.5;
    r = c + CCur; ASSERT(r == 10.5);  //Ajout d'un CCurrency à 0 et d'un Currency != 0 non entier
    CCur = 10;
    c = 0;
    r = c + CCur; ASSERT(!r.IsEmpty() && (r == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un Currency à 0
    c = 10;
    r = c + CCur; ASSERT(r == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un Currency != 0 entier
    c = 10.5;
    r = c + CCur; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 entier et d'un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    r = c + CCur; ASSERT(!r.IsEmpty() && (r == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un Currency à 0
    c = 10;
    r = c + CCur; ASSERT(r == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un Currency != 0 entier
    c = 10.5;
    r = c + CCur; ASSERT(r == 21.0);  //Ajout d'un CCurrency != 0 non entier et d'un Currency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator ++();
    CCurrency CCur;
    CCur++; ASSERT(!CCur.IsEmpty() && (CCur == 1.0));  //Incrémentation d'un CCurrency vide
    CCur = 0;
    CCur++; ASSERT(CCur == 1.0);  //Incrémentation d'un CCurrency à 0
    CCur = 10;
    CCur++; ASSERT(CCur == 11.0);  //Incrémentation d'un CCurrency != 0 entier
    CCur = 10.5;
    CCur++; ASSERT(CCur == 11.5);  //Incrémentation d'un CCurrency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator ++();
    CCurrency CCur;
    ++CCur; ASSERT(!CCur.IsEmpty() && (CCur == 1.0));  //Incrémentation d'un CCurrency vide
    CCur = 0;
    ++CCur; ASSERT(CCur == 1.0);  //Incrémentation d'un CCurrency à 0
    CCur = 10;
    ++CCur; ASSERT(CCur == 11.0);  //Incrémentation d'un CCurrency != 0 entier
    CCur = 10.5;
    ++CCur; ASSERT(CCur == 11.5);  //Incrémentation d'un CCurrency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator +();
    CCurrency CCur;
    +CCur; ASSERT(CCur.IsEmpty());  //Positif d'un CCurrency vide
    CCur = 0;
    +CCur; ASSERT(CCur == 0.0);  //Positif d'un CCurrency à 0
    CCur = 10;
    +CCur; ASSERT(CCur == 10.0);  //Positif d'un CCurrency != 0 entier
    CCur = 10.5;
    +CCur; ASSERT(CCur == 10.5);  //Positif d'un CCurrency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator +=(int Val);
    int i;
    CCurrency CCur;
    i = L_NS;
    CCur += i; ASSERT(CCur.IsEmpty());  //Ajout d'un CCurrency vide et d'un entier à L_NS
    CCur.Clear();
    i = 0;
    CCur += i; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency vide et d'un entier à 0
    CCur.Clear();
    i = 10;
    CCur += i; ASSERT(CCur == 10.0);  //Ajout d'un CCurrency vide et d'un entier != 0
    CCur = 0;
    i = L_NS;
    CCur += i; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency à 0 et d'un entier à L_NS
    CCur = 0;
    i = 0;
    CCur += i; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency à 0 et d'un entier à 0
    CCur = 0;
    i = 10;
    CCur += i; ASSERT(CCur == 10.0);  //Ajout d'un CCurrency à 0 et d'un entier != 0
    CCur = 10;
    i = L_NS;
    CCur += i; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un entier à L_NS
    CCur = 10;
    i = 0;
    CCur += i; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un entier à 0
    CCur = 10;
    i = 10;
    CCur += i; ASSERT(CCur == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un entier != 0
    CCur = 10.5;
    i = L_NS;
    CCur += i; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un entier à L_NS
    CCur = 10.5;
    i = 0;
    CCur += i; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un entier à 0
    CCur = 10.5;
    i = 10;
    CCur += i; ASSERT(CCur == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un entier != 0
  }
  {
    //inline CCurrency & __fastcall operator +=(double Val);
    double d;
    CCurrency CCur,r;
    d = D_NS;
    CCur += d; ASSERT(CCur.IsEmpty());  //Ajout d'un CCurrency vide et d'un double à D_NS
    CCur.Clear();
    d = 0;
    CCur += d; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency vide et d'un double à 0
    CCur.Clear();
    d = 10;
    CCur += d; ASSERT(CCur == 10.0);  //Ajout d'un CCurrency vide et d'un double != 0 entier
    CCur.Clear();
    d = 10.5;
    CCur += d; ASSERT(CCur == 10.5);  //Ajout d'un CCurrency vide et d'un double != 0 non entier
    CCur = 0;
    d = D_NS;
    CCur += d; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency à 0 et d'un double à D_NS
    CCur = 0;
    d = 0;
    CCur += d; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency à 0 et d'un double à 0
    CCur = 0;
    d = 10;
    CCur += d; ASSERT(CCur == 10.0);  //Ajout d'un CCurrency à 0 et d'un double != 0 entier
    CCur = 0;
    d = 10.5;
    CCur += d; ASSERT(CCur == 10.5);  //Ajout d'un CCurrency à 0 et d'un double != 0 non entier
    CCur = 10;
    d = D_NS;
    CCur += d; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un double à D_NS
    CCur = 10;
    d = 0;
    CCur += d; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un double à 0
    CCur = 10;
    d = 10;
    CCur += d; ASSERT(CCur == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un double != 0 entier
    CCur = 10;
    d = 10.5;
    CCur += d; ASSERT(CCur == 20.5);  //Ajout d'un CCurrency != 0 entier et d'un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    CCur += d; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un double à D_NS
    CCur = 10.5;
    d = 0;
    CCur += d; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un double à 0
    CCur = 10.5;
    d = 10;
    CCur += d; ASSERT(CCur == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un double != 0 entier
    CCur = 10.5;
    d = 10.5;
    CCur += d; ASSERT(CCur == 21.0);  //Ajout d'un CCurrency != 0 non entier et d'un double != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator +=(const Currency &Val);
    Currency c;
    CCurrency CCur;
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency vide et d'un Currency à 0
    CCur.Clear();
    c = 10;
    CCur += c; ASSERT(CCur == 10.0);  //Ajout d'un CCurrency vide et d'un Currency != 0 entier
    CCur.Clear();
    c = 10.5;
    CCur += c; ASSERT(CCur == 10.5);  //Ajout d'un CCurrency vide et d'un Currency != 0 non entier
    CCur = 0;
    c = 0;
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency à 0 et d'un Currency à 0
    CCur = 0;
    c = 10;
    CCur += c; ASSERT(CCur == 10.0);  //Ajout d'un CCurrency à 0 et d'un Currency != 0 entier
    CCur = 0;
    c = 10.5;
    CCur += c; ASSERT(CCur == 10.5);  //Ajout d'un CCurrency à 0 et d'un Currency != 0 non entier
    CCur = 10;
    c = 0;
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un Currency à 0
    CCur = 10;
    c = 10;
    CCur += c; ASSERT(CCur == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un Currency != 0 entier
    CCur = 10;
    c = 10.5;
    CCur += c; ASSERT(CCur == 20.5);  //Ajout d'un CCurrency != 0 entier et d'un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un Currency à 0
    CCur = 10.5;
    c = 10;
    CCur += c; ASSERT(CCur == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un Currency != 0 entier
    CCur = 10.5;
    c = 10.5;
    CCur += c; ASSERT(CCur == 21.0);  //Ajout d'un CCurrency != 0 non entier et d'un Currency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator +=(const CCurrency &Val);
    CCurrency CCur,c;
    CCur += c; ASSERT(CCur.IsEmpty());  //Ajout d'un CCurrency vide et d'un CCurrency vide
    CCur.Clear();
    c = 0;
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency vide et d'un CCurrency à 0
    CCur.Clear();
    c = 10;
    CCur += c; ASSERT(CCur == 10.0);  //Ajout d'un CCurrency vide et d'un CCurrency != 0 entier
    CCur.Clear();
    c = 10.5;
    CCur += c; ASSERT(CCur == 10.5);  //Ajout d'un CCurrency vide et d'un CCurrency != 0 non entier
    CCur = 0;
    c.Clear();
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency à 0 et d'un CCurrency vide
    CCur = 0;
    c = 0;
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Ajout d'un CCurrency à 0 et d'un CCurrency à 0
    CCur = 0;
    c = 10;
    CCur += c; ASSERT(CCur == 10.0);  //Ajout d'un CCurrency à 0 et d'un CCurrency != 0 entier
    CCur = 0;
    c = 10.5;
    CCur += c; ASSERT(CCur == 10.5);  //Ajout d'un CCurrency à 0 et d'un CCurrency != 0 non entier
    CCur = 10;
    c.Clear();
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un CCurrency vide
    CCur = 10;
    c = 0;
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Ajout d'un CCurrency != 0 entier et d'un CCurrency à 0
    CCur = 10;
    c = 10;
    CCur += c; ASSERT(CCur == 20.0);  //Ajout d'un CCurrency != 0 entier et d'un CCurrency != 0 entier
    CCur = 10;
    c = 10.5;
    CCur += c; ASSERT(CCur == 20.5);  //Ajout d'un CCurrency != 0 entier et d'un CCurrency != 0 non entier
    CCur = 10.5;
    c.Clear();
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un CCurrency vide
    CCur = 10.5;
    c = 0;
    CCur += c; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Ajout d'un CCurrency != 0 non entier et d'un CCurrency à 0
    CCur = 10.5;
    c = 10;
    CCur += c; ASSERT(CCur == 20.5);  //Ajout d'un CCurrency != 0 non entier et d'un CCurrency != 0 entier
    CCur = 10.5;
    c = 10.5;
    CCur += c; ASSERT(CCur == 21.0);  //Ajout d'un CCurrency != 0 non entier et d'un CCurrency != 0 non entier
  }
  {
    //inline CCurrency __fastcall operator -(int Val) const;
    int i;
    CCurrency CCur,r;
    i = L_NS;
    r = CCur - i; ASSERT(r.IsEmpty());  //Soustraction d'un CCurrency vide et d'un entier à L_NS
    i = 0;
    r = CCur - i; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency vide et d'un entier à 0
    i = 10;
    r = CCur - i; ASSERT(r == -10.0);  //Soustraction d'un CCurrency vide et d'un entier != 0
    CCur = 0;
    i = L_NS;
    r = CCur - i; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un entier à L_NS
    i = 0;
    r = CCur - i; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un entier à 0
    i = 10;
    r = CCur - i; ASSERT(r == -10.0);  //Soustraction d'un CCurrency à 0 et d'un entier != 0
    CCur = 10;
    i = L_NS;
    r = CCur - i; ASSERT(!r.IsEmpty() && (r == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un entier à L_NS
    i = 0;
    r = CCur - i; ASSERT(!r.IsEmpty() && (r == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un entier à 0
    i = 10;
    r = CCur - i; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un entier != 0
    CCur = 10.5;
    i = L_NS;
    r = CCur - i; ASSERT(!r.IsEmpty() && (r == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un entier à L_NS
    i = 0;
    r = CCur - i; ASSERT(!r.IsEmpty() && (r == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un entier à 0
    i = 10;
    r = CCur - i; ASSERT(r == 0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un entier != 0
  }
  {
    //inline CCurrency __fastcall operator -(double Val) const;
    double d;
    CCurrency CCur,r;
    d = D_NS;
    r = CCur - d; ASSERT(r.IsEmpty());  //Soustraction d'un CCurrency vide et d'un double à D_NS
    d = 0;
    r = CCur - d; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency vide et d'un double à 0
    d = 10;
    r = CCur - d; ASSERT(r == -10.0);  //Soustraction d'un CCurrency vide et d'un double != 0 entier
    d = 10.5;
    r = CCur - d; ASSERT(r == -10.5);  //Soustraction d'un CCurrency vide et d'un double != 0 non entier
    CCur = 0;
    d = D_NS;
    r = CCur - d; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un double à D_NS
    d = 0;
    r = CCur - d; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un double à 0
    d = 10;
    r = CCur - d; ASSERT(r == -10.0);  //Soustraction d'un CCurrency à 0 et d'un double != 0 entier
    d = 10.5;
    r = CCur - d; ASSERT(r == -10.5);  //Soustraction d'un CCurrency à 0 et d'un double != 0 non entier
    CCur = 10;
    d = D_NS;
    r = CCur - d; ASSERT(!r.IsEmpty() && (r == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un double à D_NS
    d = 0;
    r = CCur - d; ASSERT(!r.IsEmpty() && (r == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un double à 0
    d = 10;
    r = CCur - d; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un double != 0 entier
    d = 10.5;
    r = CCur - d; ASSERT(r == -0.5);  //Soustraction d'un CCurrency != 0 entier et d'un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    r = CCur - d; ASSERT(!r.IsEmpty() && (r == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un double à D_NS
    d = 0;
    r = CCur - d; ASSERT(!r.IsEmpty() && (r == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un double à 0
    d = 10;
    r = CCur - d; ASSERT(r == 0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un double != 0 entier
    d = 10.5;
    r = CCur - d; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 non entier et d'un double != 0 non entier
  }
  {
    //inline CCurrency __fastcall operator -(const Currency &Val) const;
    Currency c;
    CCurrency CCur,r;
    c = 0;
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency vide et d'un Currency à 0
    c = 10;
    r = CCur - c; ASSERT(r == -10.0);  //Soustraction d'un CCurrency vide et d'un Currency != 0 entier
    c = 10.5;
    r = CCur - c; ASSERT(r == -10.5);  //Soustraction d'un CCurrency vide et d'un Currency != 0 non entier
    CCur = 0;
    c = 0;
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un Currency à 0
    c = 10;
    r = CCur - c; ASSERT(r == -10.0);  //Soustraction d'un CCurrency à 0 et d'un Currency != 0 entier
    c = 10.5;
    r = CCur - c; ASSERT(r == -10.5);  //Soustraction d'un CCurrency à 0 et d'un Currency != 0 non entier
    CCur = 10;
    c = 0;
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un Currency à 0
    c = 10;
    r = CCur - c; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un Currency != 0 entier
    c = 10.5;
    r = CCur - c; ASSERT(r == -0.5);  //Soustraction d'un CCurrency != 0 entier et d'un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un Currency à 0
    c = 10;
    r = CCur - c; ASSERT(r == 0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un Currency != 0 entier
    c = 10.5;
    r = CCur - c; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 non entier et d'un Currency != 0 non entier
  }
  {
    //inline CCurrency __fastcall operator -(const CCurrency &Val) const;
    CCurrency CCur,c,r;
    r = CCur - c; ASSERT(r.IsEmpty());  //Soustraction d'un CCurrency vide et d'un CCurrency vide
    c = 0;
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency vide et d'un CCurrency à 0
    c = 10;
    r = CCur - c; ASSERT(r == -10.0);  //Soustraction d'un CCurrency vide et d'un CCurrency != 0 entier
    c = 10.5;
    r = CCur - c; ASSERT(r == -10.5);  //Soustraction d'un CCurrency vide et d'un CCurrency != 0 non entier
    CCur = 0;
    c.Clear();
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un CCurrency vide
    c = 0;
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un CCurrency à 0
    c = 10;
    r = CCur - c; ASSERT(r == -10.0);  //Soustraction d'un CCurrency à 0 et d'un CCurrency != 0 entier
    c = 10.5;
    r = CCur - c; ASSERT(r == -10.5);  //Soustraction d'un CCurrency à 0 et d'un CCurrency != 0 non entier
    CCur = 10;
    c.Clear();
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un CCurrency vide
    c = 0;
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un CCurrency à 0
    c = 10;
    r = CCur - c; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un CCurrency != 0 entier
    c = 10.5;
    r = CCur - c; ASSERT(r == -0.5);  //Soustraction d'un CCurrency != 0 entier et d'un CCurrency != 0 non entier
    CCur = 10.5;
    c.Clear();
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un CCurrency vide
    c = 0;
    r = CCur - c; ASSERT(!r.IsEmpty() && (r == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un CCurrency à 0
    c = 10;
    r = CCur - c; ASSERT(r == 0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un CCurrency != 0 entier
    c = 10.5;
    r = CCur - c; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 non entier et d'un CCurrency != 0 non entier
  }
  {
    //inline friend CCurrency __fastcall operator -(int ValL,const CCurrency &ValC);
    int i;
    CCurrency CCur,r;
    i = L_NS;
    r = i - CCur; ASSERT(r.IsEmpty());  //Soustraction d'un CCurrency vide et d'un entier à L_NS
    i = 0;
    r = i - CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency vide et d'un entier à 0
    i = 10;
    r = i - CCur; ASSERT(r == 10.0);  //Soustraction d'un CCurrency vide et d'un entier != 0
    CCur = 0;
    i = L_NS;
    r = i - CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un entier à L_NS
    i = 0;
    r = i - CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un entier à 0
    i = 10;
    r = i - CCur; ASSERT(r == 10.0);  //Soustraction d'un CCurrency à 0 et d'un entier != 0
    CCur = 10;
    i = L_NS;
    r = i - CCur; ASSERT(!r.IsEmpty() && (r == -10.0));  //Soustraction d'un CCurrency != 0 entier et d'un entier à L_NS
    i = 0;
    r = i - CCur; ASSERT(!r.IsEmpty() && (r == -10.0));  //Soustraction d'un CCurrency != 0 entier et d'un entier à 0
    i = 10;
    r = i - CCur; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un entier != 0
    CCur = 10.5;
    i = L_NS;
    r = i - CCur; ASSERT(!r.IsEmpty() && (r == -10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un entier à L_NS
    i = 0;
    r = i - CCur; ASSERT(!r.IsEmpty() && (r == -10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un entier à 0
    i = 10;
    r = i - CCur; ASSERT(r == -0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un entier != 0
  }
  {
    //inline friend CCurrency __fastcall operator -(double ValD,const CCurrency &ValC);
    double d;
    CCurrency CCur,r;
    d = D_NS;
    r = d - CCur; ASSERT(r.IsEmpty());  //Soustraction d'un CCurrency vide et d'un double à D_NS
    d = 0;
    r = d - CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency vide et d'un double à 0
    d = 10;
    r = d - CCur; ASSERT(r == 10.0);  //Soustraction d'un CCurrency vide et d'un double != 0 entier
    d = 10.5;
    r = d - CCur; ASSERT(r == 10.5);  //Soustraction d'un CCurrency vide et d'un double != 0 non entier
    CCur = 0;
    d = D_NS;
    r = d - CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un double à D_NS
    d = 0;
    r = d - CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un double à 0
    d = 10;
    r = d - CCur; ASSERT(r == 10.0);  //Soustraction d'un CCurrency à 0 et d'un double != 0 entier
    d = 10.5;
    r = d - CCur; ASSERT(r == 10.5);  //Soustraction d'un CCurrency à 0 et d'un double != 0 non entier
    CCur = 10;
    d = D_NS;
    r = d - CCur; ASSERT(!r.IsEmpty() && (r == -10.0));  //Soustraction d'un CCurrency != 0 entier et d'un double à D_NS
    d = 0;
    r = d - CCur; ASSERT(!r.IsEmpty() && (r == -10.0));  //Soustraction d'un CCurrency != 0 entier et d'un double à 0
    d = 10;
    r = d - CCur; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un double != 0 entier
    d = 10.5;
    r = d - CCur; ASSERT(r == 0.5);  //Soustraction d'un CCurrency != 0 entier et d'un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    r = d - CCur; ASSERT(!r.IsEmpty() && (r == -10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un double à D_NS
    d = 0;
    r = d - CCur; ASSERT(!r.IsEmpty() && (r == -10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un double à 0
    d = 10;
    r = d - CCur; ASSERT(r == -0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un double != 0 entier
    d = 10.5;
    r = d - CCur; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 non entier et d'un double != 0 non entier
  }
  {
    //inline friend CCurrency __fastcall operator -(const Currency &Val,const CCurrency &ValC);
    Currency c;
    CCurrency CCur,r;
    c = 0;
    r = c - CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency vide et d'un Currency à 0
    c = 10;
    r = c - CCur; ASSERT(r == 10.0);  //Soustraction d'un CCurrency vide et d'un Currency != 0 entier
    c = 10.5;
    r = c - CCur; ASSERT(r == 10.5);  //Soustraction d'un CCurrency vide et d'un Currency != 0 non entier
    CCur = 0;
    c = 0;
    r = c - CCur; ASSERT(!r.IsEmpty() && (r == 0.0));  //Soustraction d'un CCurrency à 0 et d'un Currency à 0
    c = 10;
    r = c - CCur; ASSERT(r == 10.0);  //Soustraction d'un CCurrency à 0 et d'un Currency != 0 entier
    c = 10.5;
    r = c - CCur; ASSERT(r == 10.5);  //Soustraction d'un CCurrency à 0 et d'un Currency != 0 non entier
    CCur = 10;
    c = 0;
    r = c - CCur; ASSERT(!r.IsEmpty() && (r == -10.0));  //Soustraction d'un CCurrency != 0 entier et d'un Currency à 0
    c = 10;
    r = c - CCur; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un Currency != 0 entier
    c = 10.5;
    r = c - CCur; ASSERT(r == 0.5);  //Soustraction d'un CCurrency != 0 entier et d'un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    r = c - CCur; ASSERT(!r.IsEmpty() && (r == -10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un Currency à 0
    c = 10;
    r = c - CCur; ASSERT(r == -0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un Currency != 0 entier
    c = 10.5;
    r = c - CCur; ASSERT(r == 0.0);  //Soustraction d'un CCurrency != 0 non entier et d'un Currency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator --();
    CCurrency CCur;
    CCur--; ASSERT(!CCur.IsEmpty() && (CCur == -1.0));  //Décrémentation d'un CCurrency vide
    CCur = 0;
    CCur--; ASSERT(CCur == -1.0);  //Décrémentation d'un CCurrency à 0
    CCur = 10;
    CCur--; ASSERT(CCur == 9.0);  //Décrémentation d'un CCurrency != 0 entier
    CCur = 10.5;
    CCur--; ASSERT(CCur == 9.5);  //Décrémentation d'un CCurrency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator --();
    CCurrency CCur;
    --CCur; ASSERT(!CCur.IsEmpty() && (CCur == -1.0));  //Décrémentation d'un CCurrency vide
    CCur = 0;
    --CCur; ASSERT(CCur == -1.0);  //Décrémentation d'un CCurrency à 0
    CCur = 10;
    --CCur; ASSERT(CCur == 9.0);  //Décrémentation d'un CCurrency != 0 entier
    CCur = 10.5;
    --CCur; ASSERT(CCur == 9.5);  //Décrémentation d'un CCurrency != 0 non entier
  }
  {
    //
    CCurrency CCur;
    -CCur; ASSERT(CCur.IsEmpty());  //Inversion d'un CCurrency vide
    CCur = 0;
    -CCur; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Inversion d'un CCurrency à 0
    CCur = 10;
    -CCur; ASSERT(CCur == -10.0);  //Inversion d'un CCurrency != 0 entier
    CCur = 10.5;
    -CCur; ASSERT(CCur == -10.5);  //Inversion d'un CCurrency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator -=(int Val);
    int i;
    CCurrency CCur;
    i = L_NS;
    CCur -= i; ASSERT(CCur.IsEmpty());  //Soustraction d'un CCurrency vide et d'un entier à L_NS
    CCur.Clear();
    i = 0;
    CCur -= i; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency vide et d'un entier à 0
    CCur.Clear();
    i = 10;
    CCur -= i; ASSERT(CCur == -10.0);  //Soustraction d'un CCurrency vide et d'un entier != 0
    CCur = 0;
    i = L_NS;
    CCur -= i; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency à 0 et d'un entier à L_NS
    CCur = 0;
    i = 0;
    CCur -= i; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency à 0 et d'un entier à 0
    CCur = 0;
    i = 10;
    CCur -= i; ASSERT(CCur == -10.0);  //Soustraction d'un CCurrency à 0 et d'un entier != 0
    CCur = 10;
    i = L_NS;
    CCur -= i; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un entier à L_NS
    CCur = 10;
    i = 0;
    CCur -= i; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un entier à 0
    CCur = 10;
    i = 10;
    CCur -= i; ASSERT(CCur == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un entier != 0
    CCur = 10.5;
    i = L_NS;
    CCur -= i; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un entier à L_NS
    CCur = 10.5;
    i = 0;
    CCur -= i; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un entier à 0
    CCur = 10.5;
    i = 10;
    CCur -= i; ASSERT(CCur == 0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un entier != 0
  }
  {
    //inline CCurrency & __fastcall operator -=(double Val);
    double d;
    CCurrency CCur,r;
    d = D_NS;
    CCur -= d; ASSERT(CCur.IsEmpty());  //Soustraction d'un CCurrency vide et d'un double à D_NS
    CCur.Clear();
    d = 0;
    CCur -= d; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency vide et d'un double à 0
    CCur.Clear();
    d = 10;
    CCur -= d; ASSERT(CCur == -10.0);  //Soustraction d'un CCurrency vide et d'un double != 0 entier
    CCur.Clear();
    d = 10.5;
    CCur -= d; ASSERT(CCur == -10.5);  //Soustraction d'un CCurrency vide et d'un double != 0 non entier
    CCur = 0;
    d = D_NS;
    CCur -= d; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency à 0 et d'un double à D_NS
    CCur = 0;
    d = 0;
    CCur -= d; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency à 0 et d'un double à 0
    CCur = 0;
    d = 10;
    CCur -= d; ASSERT(CCur == -10.0);  //Soustraction d'un CCurrency à 0 et d'un double != 0 entier
    CCur = 0;
    d = 10.5;
    CCur -= d; ASSERT(CCur == -10.5);  //Soustraction d'un CCurrency à 0 et d'un double != 0 non entier
    CCur = 10;
    d = D_NS;
    CCur -= d; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un double à D_NS
    CCur = 10;
    d = 0;
    CCur -= d; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un double à 0
    CCur = 10;
    d = 10;
    CCur -= d; ASSERT(CCur == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un double != 0 entier
    CCur = 10;
    d = 10.5;
    CCur -= d; ASSERT(CCur == -0.5);  //Soustraction d'un CCurrency != 0 entier et d'un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    CCur -= d; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un double à D_NS
    CCur = 10.5;
    d = 0;
    CCur -= d; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un double à 0
    CCur = 10.5;
    d = 10;
    CCur -= d; ASSERT(CCur == 0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un double != 0 entier
    CCur = 10.5;
    d = 10.5;
    CCur -= d; ASSERT(CCur == 0.0);  //Soustraction d'un CCurrency != 0 non entier et d'un double != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator -=(const Currency &Val);
    Currency c;
    CCurrency CCur;
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency vide et d'un Currency à 0
    CCur.Clear();
    c = 10;
    CCur -= c; ASSERT(CCur == -10.0);  //Soustraction d'un CCurrency vide et d'un Currency != 0 entier
    CCur.Clear();
    c = 10.5;
    CCur -= c; ASSERT(CCur == -10.5);  //Soustraction d'un CCurrency vide et d'un Currency != 0 non entier
    CCur = 0;
    c = 0;
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency à 0 et d'un Currency à 0
    CCur = 0;
    c = 10;
    CCur -= c; ASSERT(CCur == -10.0);  //Soustraction d'un CCurrency à 0 et d'un Currency != 0 entier
    CCur = 0;
    c = 10.5;
    CCur -= c; ASSERT(CCur == -10.5);  //Soustraction d'un CCurrency à 0 et d'un Currency != 0 non entier
    CCur = 10;
    c = 0;
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un Currency à 0
    CCur = 10;
    c = 10;
    CCur -= c; ASSERT(CCur == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un Currency != 0 entier
    CCur = 10;
    c = 10.5;
    CCur -= c; ASSERT(CCur == -0.5);  //Soustraction d'un CCurrency != 0 entier et d'un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un Currency à 0
    CCur = 10.5;
    c = 10;
    CCur -= c; ASSERT(CCur == 0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un Currency != 0 entier
    CCur = 10.5;
    c = 10.5;
    CCur -= c; ASSERT(CCur == 0.0);  //Soustraction d'un CCurrency != 0 non entier et d'un Currency != 0 non entier
  }
  {
    //inline CCurrency & __fastcall operator -=(const CCurrency &Val);
    CCurrency CCur,c;
    CCur -= c; ASSERT(CCur.IsEmpty());  //Soustraction d'un CCurrency vide et d'un CCurrency vide
    CCur.Clear();
    c = 0;
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency vide et d'un CCurrency à 0
    CCur.Clear();
    c = 10;
    CCur -= c; ASSERT(CCur == -10.0);  //Soustraction d'un CCurrency vide et d'un CCurrency != 0 entier
    CCur.Clear();
    c = 10.5;
    CCur -= c; ASSERT(CCur == -10.5);  //Soustraction d'un CCurrency vide et d'un CCurrency != 0 non entier
    CCur = 0;
    c.Clear();
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency à 0 et d'un CCurrency vide
    CCur = 0;
    c = 0;
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 0.0));  //Soustraction d'un CCurrency à 0 et d'un CCurrency à 0
    CCur = 0;
    c = 10;
    CCur -= c; ASSERT(CCur == -10.0);  //Soustraction d'un CCurrency à 0 et d'un CCurrency != 0 entier
    CCur = 0;
    c = 10.5;
    CCur -= c; ASSERT(CCur == -10.5);  //Soustraction d'un CCurrency à 0 et d'un CCurrency != 0 non entier
    CCur = 10;
    c.Clear();
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un CCurrency vide
    CCur = 10;
    c = 0;
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 10.0));  //Soustraction d'un CCurrency != 0 entier et d'un CCurrency à 0
    CCur = 10;
    c = 10;
    CCur -= c; ASSERT(CCur == 0.0);  //Soustraction d'un CCurrency != 0 entier et d'un CCurrency != 0 entier
    CCur = 10;
    c = 10.5;
    CCur -= c; ASSERT(CCur == -0.5);  //Soustraction d'un CCurrency != 0 entier et d'un CCurrency != 0 non entier
    CCur = 10.5;
    c.Clear();
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un CCurrency vide
    CCur = 10.5;
    c = 0;
    CCur -= c; ASSERT(!CCur.IsEmpty() && (CCur == 10.5));  //Soustraction d'un CCurrency != 0 non entier et d'un CCurrency à 0
    CCur = 10.5;
    c = 10;
    CCur -= c; ASSERT(CCur == 0.5);  //Soustraction d'un CCurrency != 0 non entier et d'un CCurrency != 0 entier
    CCur = 10.5;
    c = 10.5;
    CCur -= c; ASSERT(CCur == 0.0);  //Soustraction d'un CCurrency != 0 non entier et d'un CCurrency != 0 non entier
  }
  {
    //CCurrency __fastcall operator *(int Multiplicateur) const;
    int i;
    CCurrency CCur,r;
    i = L_NS;
    r = CCur * i; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un entier à L_NS
    i = 0;
    r = CCur * i; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un entier à 0
    i = 10;
    r = CCur * i; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un entier != 0
    CCur = 0;
    i = L_NS;
    r = CCur * i; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency à 0 avec un entier à L_NS
    i = 0;
    r = CCur * i; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un entier à 0
    i = 10;
    r = CCur * i; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un entier != 0
    CCur = 10;
    i = L_NS;
    r = CCur * i; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 entier avec un entier à L_NS
    i = 0;
    r = CCur * i; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 entier avec un entier à 0
    i = 10;
    r = CCur * i; ASSERT(r == 100);  //Multiplication d'un CCurrency != 0 entier avec un entier != 0
    CCur = 10.5;
    i = L_NS;
    r = CCur * i; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 non entier avec un entier à L_NS
    i = 0;
    r = CCur * i; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 non entier avec un entier à 0
    i = 10;
    r = CCur * i; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 non entier avec un entier != 0
  }
  {
    //CCurrency __fastcall operator *(double Multiplicateur) const;
    double d;
    CCurrency CCur,r;
    d = D_NS;
    r = CCur * d; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un double à D_NS
    d = 0;
    r = CCur * d; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un double à 0
    d = 10;
    r = CCur * d; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un double != 0 entier
    d = 10.5;
    r = CCur * d; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un double != 0 non entier
    CCur = 0;
    d = D_NS;
    r = CCur * d; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency à 0 avec un double à D_NS
    d = 0;
    r = CCur * d; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un double à 0
    d = 10;
    r = CCur * d; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un double != 0 entier
    d = 10.5;
    r = CCur * d; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un double != 0 non entier
    CCur = 10;
    d = D_NS;
    r = CCur * d; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 entier avec un double à D_NS
    d = 0;
    r = CCur * d; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 entier avec un double à 0
    d = 10;
    r = CCur * d; ASSERT(r == 100);  //Multiplication d'un CCurrency != 0 entier avec un double != 0 entier
    d = 10.5;
    r = CCur * d; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 entier avec un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    r = CCur * d; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 non entier avec un double à D_NS
    d = 0;
    r = CCur * d; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 non entier avec un double à 0
    d = 10;
    r = CCur * d; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 non entier avec un double != 0 entier
    d = 10.5;
    r = CCur * d; ASSERT(r == 110.25);  //Multiplication d'un CCurrency != 0 non entier avec un double != 0 non entier
  }
  {
    //CCurrency __fastcall operator *(const Currency &Multiplicateur) const;
    Currency c;
    CCurrency CCur,r;
    c = 0;
    r = CCur * c; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un Currency à 0
    c = 10;
    r = CCur * c; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un Currency != 0 entier
    c = 10.5;
    r = CCur * c; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un Currency != 0 non entier
    CCur = 0;
    c = 0;
    r = CCur * c; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un Currency à 0
    c = 10;
    r = CCur * c; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un Currency != 0 entier
    c = 10.5;
    r = CCur * c; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un Currency != 0 non entier
    CCur = 10;
    c = 0;
    r = CCur * c; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 entier avec un Currency à 0
    c = 10;
    r = CCur * c; ASSERT(r == 100);  //Multiplication d'un CCurrency != 0 entier avec un Currency != 0 entier
    c = 10.5;
    r = CCur * c; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 entier avec un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    r = CCur * c; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 non entier avec un Currency à 0
    c = 10;
    r = CCur * c; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 non entier avec un Currency != 0 entier
    c = 10.5;
    r = CCur * c; ASSERT(r == 110.25);  //Multiplication d'un CCurrency != 0 non entier avec un Currency != 0 non entier
  }
  {
    //CCurrency __fastcall operator *(const CCurrency &Multiplicateur) const;
    CCurrency CCur,CCur2,r;
    r = CCur * CCur2; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un CCurrency vide
    CCur2 = 0;
    r = CCur * CCur2; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un CCurrency à 0
    CCur2 = 10;
    r = CCur * CCur2; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un CCurrency != 0 entier
    CCur2 = 10.5;
    r = CCur * CCur2; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un CCurrency != 0 non entier
    CCur = 0;
    CCur2.Clear();
    r = CCur * CCur2; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency à 0 avec un CCurrency vide
    CCur2 = 0;
    r = CCur * CCur2; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un CCurrency à 0
    CCur2 = 10;
    r = CCur * CCur2; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un CCurrency != 0 entier
    CCur2 = 10.5;
    r = CCur * CCur2; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un CCurrency != 0 non entier
    CCur = 10;
    CCur2.Clear();
    r = CCur * CCur2; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 entier avec un CCurrency vide
    CCur2 = 0;
    r = CCur * CCur2; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 entier avec un CCurrency à 0
    CCur2 = 10;
    r = CCur * CCur2; ASSERT(r == 100);  //Multiplication d'un CCurrency != 0 entier avec un CCurrency != 0 entier
    CCur2 = 10.5;
    r = CCur * CCur2; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 entier avec un CCurrency != 0 non entier
    CCur = 10.5;
    CCur2.Clear();
    r = CCur * CCur2; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 non entier avec un CCurrency vide
    CCur2 = 0;
    r = CCur * CCur2; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 non entier avec un CCurrency à 0
    CCur2 = 10;
    r = CCur * CCur2; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 non entier avec un CCurrency != 0 entier
    CCur2 = 10.5;
    r = CCur * CCur2; ASSERT(r == 110.25);  //Multiplication d'un CCurrency != 0 non entier avec un CCurrency != 0 non entier
  }
  {
    //inline friend CCurrency __fastcall operator *(int Multiplicateur,const CCurrency &Val);
    int i;
    CCurrency CCur,r;
    i = L_NS;
    r = i * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un entier à L_NS
    i = 0;
    r = i * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un entier à 0
    i = 10;
    r = i * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un entier != 0
    CCur = 0;
    i = L_NS;
    r = i * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency à 0 avec un entier à L_NS
    i = 0;
    r = i * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un entier à 0
    i = 10;
    r = i * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un entier != 0
    CCur = 10;
    i = L_NS;
    r = i * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 entier avec un entier à L_NS
    i = 0;
    r = i * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 entier avec un entier à 0
    i = 10;
    r = i * CCur; ASSERT(r == 100);  //Multiplication d'un CCurrency != 0 entier avec un entier != 0
    CCur = 10.5;
    i = L_NS;
    r = i * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 non entier avec un entier à L_NS
    i = 0;
    r = i * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 non entier avec un entier à 0
    i = 10;
    r = i * CCur; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 non entier avec un entier != 0
  }
  {
    //inline friend CCurrency __fastcall operator *(double Multiplicateur,const CCurrency &Val);
    double d;
    CCurrency CCur,r;
    d = D_NS;
    r = d * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un double à D_NS
    d = 0;
    r = d * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un double à 0
    d = 10;
    r = d * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un double != 0 entier
    d = 10.5;
    r = d * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un double != 0 non entier
    CCur = 0;
    d = D_NS;
    r = d * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency à 0 avec un double à D_NS
    d = 0;
    r = d * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un double à 0
    d = 10;
    r = d * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un double != 0 entier
    d = 10.5;
    r = d * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un double != 0 non entier
    CCur = 10;
    d = D_NS;
    r = d * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 entier avec un double à D_NS
    d = 0;
    r = d * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 entier avec un double à 0
    d = 10;
    r = d * CCur; ASSERT(r == 100);  //Multiplication d'un CCurrency != 0 entier avec un double != 0 entier
    d = 10.5;
    r = d * CCur; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 entier avec un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    r = d * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency != 0 non entier avec un double à D_NS
    d = 0;
    r = d * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 non entier avec un double à 0
    d = 10;
    r = d * CCur; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 non entier avec un double != 0 entier
    d = 10.5;
    r = d * CCur; ASSERT(r == 110.25);  //Multiplication d'un CCurrency != 0 non entier avec un double != 0 non entier
  }
  {
    //inline friend CCurrency __fastcall operator *(const Currency &Multiplicateur,const CCurrency &Val);
    Currency c;
    CCurrency CCur,r;
    c = 0;
    r = c * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un Currency à 0
    c = 10;
    r = c * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un Currency != 0 entier
    c = 10.5;
    r = c * CCur; ASSERT(r.IsEmpty());  //Multiplication d'un CCurrency vide avec un Currency != 0 non entier
    CCur = 0;
    c = 0;
    r = c * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un Currency à 0
    c = 10;
    r = c * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un Currency != 0 entier
    c = 10.5;
    r = c * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency à 0 avec un Currency != 0 non entier
    CCur = 10;
    c = 0;
    r = c * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 entier avec un Currency à 0
    c = 10;
    r = c * CCur; ASSERT(r == 100);  //Multiplication d'un CCurrency != 0 entier avec un Currency != 0 entier
    c = 10.5;
    r = c * CCur; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 entier avec un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    r = c * CCur; ASSERT(r == 0);  //Multiplication d'un CCurrency != 0 non entier avec un Currency à 0
    c = 10;
    r = c * CCur; ASSERT(r == 105);  //Multiplication d'un CCurrency != 0 non entier avec un Currency != 0 entier
    c = 10.5;
    r = c * CCur; ASSERT(r == 110.25);  //Multiplication d'un CCurrency != 0 non entier avec un Currency != 0 non entier
  }
  {
    //CCurrency & __fastcall operator *=(int Multiplicateur);
    int i;
    CCurrency CCur;
    i = L_NS;
    CCur *= i; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un entier à L_NS
    CCur.Clear();
    i = 0;
    CCur *= i; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un entier à 0
    CCur.Clear();
    i = 10;
    CCur *= i; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un entier != 0
    CCur = 0;
    i = L_NS;
    CCur *= i; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency à 0 avec un entier à L_NS
    CCur = 0;
    i = 0;
    CCur *= i; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un entier à 0
    CCur = 0;
    i = 10;
    CCur *= i; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un entier != 0
    CCur = 10;
    i = L_NS;
    CCur *= i; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency != 0 entier avec un entier à L_NS
    CCur = 10;
    i = 0;
    CCur *= i; ASSERT(CCur == 0);  //Multiplication d'un CCurrency != 0 entier avec un entier à 0
    CCur = 10;
    i = 10;
    CCur *= i; ASSERT(CCur == 100);  //Multiplication d'un CCurrency != 0 entier avec un entier != 0
    CCur = 10.5;
    i = L_NS;
    CCur *= i; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency != 0 non entier avec un entier à L_NS
    CCur = 10.5;
    i = 0;
    CCur *= i; ASSERT(CCur == 0);  //Multiplication d'un CCurrency != 0 non entier avec un entier à 0
    CCur = 10.5;
    i = 10;
    CCur *= i; ASSERT(CCur == 105);  //Multiplication d'un CCurrency != 0 non entier avec un entier != 0
  }
  {
    //CCurrency & __fastcall operator *=(double Multiplicateur);
    double d;
    CCurrency CCur;
    d = D_NS;
    CCur *= d; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un double à D_NS
    CCur.Clear();
    d = 0;
    CCur *= d; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un double à 0
    CCur.Clear();
    d = 10;
    CCur *= d; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un double != 0 entier
    CCur.Clear();
    d = 10.5;
    CCur *= d; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un double != 0 non entier
    CCur = 0;
    d = D_NS;
    CCur *= d; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency à 0 avec un double à D_NS
    CCur = 0;
    d = 0;
    CCur *= d; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un double à 0
    CCur = 0;
    d = 10;
    CCur *= d; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un double != 0 entier
    CCur = 0;
    d = 10.5;
    CCur *= d; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un double != 0 non entier
    CCur = 10;
    d = D_NS;
    CCur *= d; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency != 0 entier avec un double à D_NS
    CCur = 10;
    d = 0;
    CCur *= d; ASSERT(CCur == 0);  //Multiplication d'un CCurrency != 0 entier avec un double à 0
    CCur = 10;
    d = 10;
    CCur *= d; ASSERT(CCur == 100);  //Multiplication d'un CCurrency != 0 entier avec un double != 0 entier
    CCur = 10;
    d = 10.5;
    CCur *= d; ASSERT(CCur == 105);  //Multiplication d'un CCurrency != 0 entier avec un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    CCur *= d; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency != 0 non entier avec un double à D_NS
    CCur = 10.5;
    d = 0;
    CCur *= d; ASSERT(CCur == 0);  //Multiplication d'un CCurrency != 0 non entier avec un double à 0
    CCur = 10.5;
    d = 10;
    CCur *= d; ASSERT(CCur == 105);  //Multiplication d'un CCurrency != 0 non entier avec un double != 0 entier
    CCur = 10.5;
    d = 10.5;
    CCur *= d; ASSERT(CCur == 110.25);  //Multiplication d'un CCurrency != 0 non entier avec un double != 0 non entier
  }
  {
    //CCurrency & __fastcall operator *=(const Currency &Multiplicateur);
    Currency c;
    CCurrency CCur;
    c = 0;
    CCur *= c; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un Currency à 0
    CCur.Clear();
    c = 10;
    CCur *= c; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un Currency != 0 entier
    CCur.Clear();
    c = 10.5;
    CCur *= c; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un Currency != 0 non entier
    CCur = 0;
    c = 0;
    CCur *= c; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un Currency à 0
    CCur = 0;
    c = 10;
    CCur *= c; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un Currency != 0 entier
    CCur = 0;
    c = 10.5;
    CCur *= c; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un Currency != 0 non entier
    CCur = 10;
    c = 0;
    CCur *= c; ASSERT(CCur == 0);  //Multiplication d'un CCurrency != 0 entier avec un Currency à 0
    CCur = 10;
    c = 10;
    CCur *= c; ASSERT(CCur == 100);  //Multiplication d'un CCurrency != 0 entier avec un Currency != 0 entier
    CCur = 10;
    c = 10.5;
    CCur *= c; ASSERT(CCur == 105);  //Multiplication d'un CCurrency != 0 entier avec un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    CCur *= c; ASSERT(CCur == 0);  //Multiplication d'un CCurrency != 0 non entier avec un Currency à 0
    CCur = 10.5;
    c = 10;
    CCur *= c; ASSERT(CCur == 105);  //Multiplication d'un CCurrency != 0 non entier avec un Currency != 0 entier
    CCur = 10.5;
    c = 10.5;
    CCur *= c; ASSERT(CCur == 110.25);  //Multiplication d'un CCurrency != 0 non entier avec un Currency != 0 non entier
  }
  {
    //CCurrency & __fastcall operator *=(const CCurrency &Multiplicateur);
    CCurrency CCur,CCur2;
    CCur *= CCur2; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un CCurrency vide
    CCur.Clear();
    CCur2 = 0;
    CCur *= CCur2; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un CCurrency à 0
    CCur.Clear();
    CCur2 = 10;
    CCur *= CCur2; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un CCurrency != 0 entier
    CCur.Clear();
    CCur2 = 10.5;
    CCur *= CCur2; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency vide avec un CCurrency != 0 non entier
    CCur = 0;
    CCur2.Clear();
    CCur *= CCur2; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency à 0 avec un CCurrency vide
    CCur = 0;
    CCur2 = 0;
    CCur *= CCur2; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un CCurrency à 0
    CCur = 0;
    CCur2 = 10;
    CCur *= CCur2; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un CCurrency != 0 entier
    CCur = 0;
    CCur2 = 10.5;
    CCur *= CCur2; ASSERT(CCur == 0);  //Multiplication d'un CCurrency à 0 avec un CCurrency != 0 non entier
    CCur = 10;
    CCur2.Clear();
    CCur *= CCur2; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency != 0 entier avec un CCurrency vide
    CCur = 10;
    CCur2 = 0;
    CCur *= CCur2; ASSERT(CCur == 0);  //Multiplication d'un CCurrency != 0 entier avec un CCurrency à 0
    CCur = 10;
    CCur2 = 10;
    CCur *= CCur2; ASSERT(CCur == 100);  //Multiplication d'un CCurrency != 0 entier avec un CCurrency != 0 entier
    CCur = 10;
    CCur2 = 10.5;
    CCur *= CCur2; ASSERT(CCur == 105);  //Multiplication d'un CCurrency != 0 entier avec un CCurrency != 0 non entier
    CCur = 10.5;
    CCur2.Clear();
    CCur *= CCur2; ASSERT(CCur.IsEmpty());  //Multiplication d'un CCurrency != 0 non entier avec un CCurrency vide
    CCur = 10.5;
    CCur2 = 0;
    CCur *= CCur2; ASSERT(CCur == 0);  //Multiplication d'un CCurrency != 0 non entier avec un CCurrency à 0
    CCur = 10.5;
    CCur2 = 10;
    CCur *= CCur2; ASSERT(CCur == 105);  //Multiplication d'un CCurrency != 0 non entier avec un CCurrency != 0 entier
    CCur = 10.5;
    CCur2 = 10.5;
    CCur *= CCur2; ASSERT(CCur == 110.25);  //Multiplication d'un CCurrency != 0 non entier avec un CCurrency != 0 non entier
  }
  {
    //CCurrency __fastcall operator /(int Diviseur) const;
    int i;
    CCurrency CCur,r;
    i = L_NS;
    try
      {
        r = CCur / i; ASSERT(false);  //Division d'un CCurrency vide avec un entier à L_NS
      }
    catch (...)
      {
      }
    i = 0;
    try
      {
        r = CCur / i; ASSERT(false);  //Division d'un CCurrency vide avec un entier à 0
      }
    catch (...)
      {
      }
    i = 10;
    r = CCur / i; ASSERT(r.IsEmpty());  //Division d'un CCurrency vide avec un entier != 0
    CCur = 0;
    i = L_NS;
    try
      {
        r = CCur / i; ASSERT(false);  //Division d'un CCurrency à 0 avec un entier à L_NS
      }
    catch (...)
      {
      }
    i = 0;
    try
      {
        r = CCur / i; ASSERT(false);  //Division d'un CCurrency à 0 avec un entier à 0
      }
    catch (...)
      {
      }
    i = 10;
    r = CCur / i; ASSERT(r == 0);  //Division d'un CCurrency à 0 avec un entier != 0
    CCur = 10;
    i = L_NS;
    try
      {
        r = CCur / i; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un entier à L_NS
      }
    catch (...)
      {
      }
    i = 0;
    try
      {
        r = CCur / i; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un entier à 0
      }
    catch (...)
      {
      }
    i = 10;
    r = CCur / i; ASSERT(r == 1);  //Division d'un CCurrency != 0 entier avec un entier != 0
    CCur = 10.5;
    i = L_NS;
    try
      {
        r = CCur / i; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un entier à L_NS
      }
    catch (...)
      {
      }
    i = 0;
    try
      {
        r = CCur / i; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un entier à 0
      }
    catch (...)
      {
      }
    i = 10;
    r = CCur / i; ASSERT(r == 1.05);  //Division d'un CCurrency != 0 non entier avec un entier != 0
  }
  {
    //CCurrency __fastcall operator /(double Diviseur) const;
    double d;
    CCurrency CCur,r;
    d = D_NS;
    try
      {
        r = CCur / d; ASSERT(false);  //Division d'un CCurrency vide avec un double à D_NS
      }
    catch (...)
      {
      }
    d = 0;
    try
      {
        r = CCur / d; ASSERT(false);  //Division d'un CCurrency vide avec un double à 0
      }
    catch (...)
      {
      }
    d = 10;
    r = CCur / d; ASSERT(r.IsEmpty());  //Division d'un CCurrency vide avec un double != 0 entier
    d = 10.5;
    r = CCur / d; ASSERT(r.IsEmpty());  //Division d'un CCurrency vide avec un double != 0 non entier
    CCur = 0;
    d = D_NS;
    try
      {
        r = CCur / d; ASSERT(false);  //Division d'un CCurrency à 0 avec un double à D_NS
      }
    catch (...)
      {
      }
    d = 0;
    try
      {
        r = CCur / d; ASSERT(false);  //Division d'un CCurrency à 0 avec un double à 0
      }
    catch (...)
      {
      }
    d = 10;
    r = CCur / d; ASSERT(r == 0);  //Division d'un CCurrency à 0 avec un double != 0 entier
    d = 10.5;
    r = CCur / d; ASSERT(r == 0);  //Division d'un CCurrency à 0 avec un double != 0 non entier
    CCur = 10;
    d = D_NS;
    try
      {
        r = CCur / d; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un double à D_NS
      }
    catch (...)
      {
      }
    d = 0;
    try
      {
        r = CCur / d; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un double à 0
      }
    catch (...)
      {
      }
    d = 10;
    r = CCur / d; ASSERT(r == 1);  //Division d'un CCurrency != 0 entier avec un double != 0 entier
    d = 10.5;
    r = CCur / d; ASSERT(r == 0.9523);  //Division d'un CCurrency != 0 entier avec un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    try
      {
        r = CCur / d; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un double à D_NS
      }
    catch (...)
      {
      }
    d = 0;
    try
      {
        r = CCur / d; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un double à 0
      }
    catch (...)
      {
      }
    d = 10;
    r = CCur / d; ASSERT(r == 1.05);  //Division d'un CCurrency != 0 non entier avec un double != 0 entier
    d = 10.5;
    r = CCur / d; ASSERT(r == 1);  //Division d'un CCurrency != 0 non entier avec un double != 0 non entier
  }
  {
    //CCurrency __fastcall operator /(const Currency &Diviseur) const;
    Currency c;
    CCurrency CCur,r;
    c = 0;
    try
      {
        r = CCur / c; ASSERT(false);  //Division d'un CCurrency vide avec un Currency à 0
      }
    catch (...)
      {
      }
    c = 10;
    r = CCur / c; ASSERT(r.IsEmpty());  //Division d'un CCurrency vide avec un Currency != 0 entier
    c = 10.5;
    r = CCur / c; ASSERT(r.IsEmpty());  //Division d'un CCurrency vide avec un Currency != 0 non entier
    CCur = 0;
    c = 0;
    try
      {
        r = CCur / c; ASSERT(false);  //Division d'un CCurrency à 0 avec un Currency à 0
      }
    catch (...)
      {
      }
    c = 10;
    r = CCur / c; ASSERT(r == 0);  //Division d'un CCurrency à 0 avec un Currency != 0 entier
    c = 10.5;
    r = CCur / c; ASSERT(r == 0);  //Division d'un CCurrency à 0 avec un Currency != 0 non entier
    CCur = 10;
    c = 0;
    try
      {
        r = CCur / c; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un Currency à 0
      }
    catch (...)
      {
      }
    c = 10;
    r = CCur / c; ASSERT(r == 1);  //Division d'un CCurrency != 0 entier avec un Currency != 0 entier
    c = 10.5;
    r = CCur / c; ASSERT(r == 0.9523);  //Division d'un CCurrency != 0 entier avec un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    try
      {
        r = CCur / c; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un Currency à 0
      }
    catch (...)
      {
      }
    c = 10;
    r = CCur / c; ASSERT(r == 1.05);  //Division d'un CCurrency != 0 non entier avec un Currency != 0 entier
    c = 10.5;
    r = CCur / c; ASSERT(r == 1);  //Division d'un CCurrency != 0 non entier avec un Currency != 0 non entier
  }
  {
    //CCurrency __fastcall operator /(const CCurrency &Diviseur) const;
    CCurrency CCur,CCur2,r;
    CCur2.Clear();
    try
      {
        r = CCur / CCur2; ASSERT(false);  //Division d'un CCurrency vide avec un CCurrency vide
      }
    catch (...)
      {
      }
    CCur2 = 0;
    try
      {
        r = CCur / CCur2; ASSERT(false);  //Division d'un CCurrency vide avec un CCurrency à 0
      }
    catch (...)
      {
      }
    CCur2 = 10;
    r = CCur / CCur2; ASSERT(r.IsEmpty());  //Division d'un CCurrency vide avec un CCurrency != 0 entier
    CCur2 = 10.5;
    r = CCur / CCur2; ASSERT(r.IsEmpty());  //Division d'un CCurrency vide avec un CCurrency != 0 non entier
    CCur = 0;
    CCur2.Clear();
    try
      {
        r = CCur / CCur2; ASSERT(false);  //Division d'un CCurrency à 0 avec un CCurrency vide
      }
    catch (...)
      {
      }
    CCur2 = 0;
    try
      {
        r = CCur / CCur2; ASSERT(false);  //Division d'un CCurrency à 0 avec un CCurrency à 0
      }
    catch (...)
      {
      }
    CCur2 = 10;
    r = CCur / CCur2; ASSERT(r == 0);  //Division d'un CCurrency à 0 avec un CCurrency != 0 entier
    CCur2 = 10.5;
    r = CCur / CCur2; ASSERT(r == 0);  //Division d'un CCurrency à 0 avec un CCurrency != 0 non entier
    CCur = 10;
    CCur2.Clear();
    try
      {
        r = CCur / CCur2; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un CCurrency vide
      }
    catch (...)
      {
      }
    CCur2 = 0;
    try
      {
        r = CCur / CCur2; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un CCurrency à 0
      }
    catch (...)
      {
      }
    CCur2 = 10;
    r = CCur / CCur2; ASSERT(r == 1);  //Division d'un CCurrency != 0 entier avec un CCurrency != 0 entier
    CCur2 = 10.5;
    r = CCur / CCur2; ASSERT(r == 0.9523);  //Division d'un CCurrency != 0 entier avec un CCurrency != 0 non entier
    CCur = 10.5;
    CCur2.Clear();
    try
      {
        r = CCur / CCur2; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un CCurrency vide
      }
    catch (...)
      {
      }
    CCur2 = 0;
    try
      {
        r = CCur / CCur2; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un CCurrency à 0
      }
    catch (...)
      {
      }
    CCur2 = 10;
    r = CCur / CCur2; ASSERT(r == 1.05);  //Division d'un CCurrency != 0 non entier avec un CCurrency != 0 entier
    CCur2 = 10.5;
    r = CCur / CCur2; ASSERT(r == 1);  //Division d'un CCurrency != 0 non entier avec un CCurrency != 0 non entier
  }
  {
    //CCurrency & __fastcall operator /=(int Multiplicateur);
    int i;
    CCurrency CCur;
    i = L_NS;
    try
      {
        CCur /= i; ASSERT(false);  //Division d'un CCurrency vide avec un entier à L_NS
      }
    catch (...)
      {
      }
    CCur.Clear();
    i = 0;
    try
      {
        CCur /= i; ASSERT(false);  //Division d'un CCurrency vide avec un entier à 0
      }
    catch (...)
      {
      }
    CCur.Clear();
    i = 10;
    CCur /= i; ASSERT(CCur.IsEmpty());  //Division d'un CCurrency vide avec un entier != 0
    CCur = 0;
    i = L_NS;
    try
      {
        CCur /= i; ASSERT(false);  //Division d'un CCurrency à 0 avec un entier à L_NS
      }
    catch (...)
      {
      }
    CCur = 0;
    i = 0;
    try
      {
        CCur /= i; ASSERT(false);  //Division d'un CCurrency à 0 avec un entier à 0
      }
    catch (...)
      {
      }
    CCur = 0;
    i = 10;
    CCur /= i; ASSERT(CCur == 0);  //Division d'un CCurrency à 0 avec un entier != 0
    CCur = 10;
    i = L_NS;
    try
      {
        CCur /= i; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un entier à L_NS
      }
    catch (...)
      {
      }
    CCur = 10;
    i = 0;
    try
      {
        CCur /= i; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un entier à 0
      }
    catch (...)
      {
      }
    CCur = 10;
    i = 10;
    CCur /= i; ASSERT(CCur == 1);  //Division d'un CCurrency != 0 entier avec un entier != 0
    CCur = 10.5;
    i = L_NS;
    try
      {
        CCur /= i; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un entier à L_NS
      }
    catch (...)
      {
      }
    CCur = 10.5;
    i = 0;
    try
      {
        CCur /= i; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un entier à 0
      }
    catch (...)
      {
      }
    CCur = 10.5;
    i = 10;
    CCur /= i; ASSERT(CCur == 1.05);  //Division d'un CCurrency != 0 non entier avec un entier != 0
  }
  {
    //CCurrency & __fastcall operator /=(double Diviseur);
    double d;
    CCurrency CCur;
    d = D_NS;
    try
      {
        CCur /= d; ASSERT(false);  //Division d'un CCurrency vide avec un double à D_NS
      }
    catch (...)
      {
      }
    CCur.Clear();
    d = 0;
    try
      {
        CCur /= d; ASSERT(false);  //Division d'un CCurrency vide avec un double à 0
      }
    catch (...)
      {
      }
    CCur.Clear();
    d = 10;
    CCur /= d; ASSERT(CCur.IsEmpty());  //Division d'un CCurrency vide avec un double != 0 entier
    CCur.Clear();
    d = 10.5;
    CCur /= d; ASSERT(CCur.IsEmpty());  //Division d'un CCurrency vide avec un double != 0 non entier
    CCur = 0;
    d = D_NS;
    try
      {
        CCur /= d; ASSERT(false);  //Division d'un CCurrency à 0 avec un double à D_NS
      }
    catch (...)
      {
      }
    CCur = 0;
    d = 0;
    try
      {
        CCur /= d; ASSERT(false);  //Division d'un CCurrency à 0 avec un double à 0
      }
    catch (...)
      {
      }
    CCur = 0;
    d = 10;
    CCur /= d; ASSERT(CCur == 0);  //Division d'un CCurrency à 0 avec un double != 0 entier
    CCur = 0;
    d = 10.5;
    CCur /= d; ASSERT(CCur == 0);  //Division d'un CCurrency à 0 avec un double != 0 non entier
    CCur = 10;
    d = D_NS;
    try
      {
        CCur /= d; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un double à D_NS
      }
    catch (...)
      {
      }
    CCur = 10;
    d = 0;
    try
      {
        CCur /= d; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un double à 0
      }
    catch (...)
      {
      }
    CCur = 10;
    d = 10;
    CCur /= d; ASSERT(CCur == 1);  //Division d'un CCurrency != 0 entier avec un double != 0 entier
    CCur = 10;
    d = 10.5;
    CCur /= d; ASSERT(CCur == 0.9523);  //Division d'un CCurrency != 0 entier avec un double != 0 non entier
    CCur = 10.5;
    d = D_NS;
    try
      {
        CCur /= d; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un double à D_NS
      }
    catch (...)
      {
      }
    CCur = 10.5;
    d = 0;
    try
      {
        CCur /= d; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un double à 0
      }
    catch (...)
      {
      }
    CCur = 10.5;
    d = 10;
    CCur /= d; ASSERT(CCur == 1.05);  //Division d'un CCurrency != 0 non entier avec un double != 0 entier
    CCur = 10.5;
    d = 10.5;
    CCur /= d; ASSERT(CCur == 1);  //Division d'un CCurrency != 0 non entier avec un double != 0 non entier
  }
  {
    //CCurrency & __fastcall operator /=(const Currency &Diviseur);
    Currency c;
    CCurrency CCur;
    c = 0;
    try
      {
        CCur /= c; ASSERT(false);  //Division d'un CCurrency vide avec un Currency à 0
      }
    catch (...)
      {
      }
    CCur.Clear();
    c = 10;
    CCur /= c; ASSERT(CCur.IsEmpty());  //Division d'un CCurrency vide avec un Currency != 0 entier
    CCur.Clear();
    c = 10.5;
    CCur /= c; ASSERT(CCur.IsEmpty());  //Division d'un CCurrency vide avec un Currency != 0 non entier
    CCur = 0;
    c = 0;
    try
      {
        CCur /= c; ASSERT(false);  //Division d'un CCurrency à 0 avec un Currency à 0
      }
    catch (...)
      {
      }
    CCur = 0;
    c = 10;
    CCur /= c; ASSERT(CCur == 0);  //Division d'un CCurrency à 0 avec un Currency != 0 entier
    CCur = 0;
    c = 10.5;
    CCur /= c; ASSERT(CCur == 0);  //Division d'un CCurrency à 0 avec un Currency != 0 non entier
    CCur = 10;
    c = 0;
    try
      {
        CCur /= c; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un Currency à 0
      }
    catch (...)
      {
      }
    CCur = 10;
    c = 10;
    CCur /= c; ASSERT(CCur == 1);  //Division d'un CCurrency != 0 entier avec un Currency != 0 entier
    CCur = 10;
    c = 10.5;
    CCur /= c; ASSERT(CCur == 0.9523);  //Division d'un CCurrency != 0 entier avec un Currency != 0 non entier
    CCur = 10.5;
    c = 0;
    try
      {
        CCur /= c; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un Currency à 0
      }
    catch (...)
      {
      }
    CCur = 10.5;
    c = 10;
    CCur /= c; ASSERT(CCur == 1.05);  //Division d'un CCurrency != 0 non entier avec un Currency != 0 entier
    CCur = 10.5;
    c = 10.5;
    CCur /= c; ASSERT(CCur == 1);  //Division d'un CCurrency != 0 non entier avec un Currency != 0 non entier
  }
  {
    //CCurrency & __fastcall operator /=(const CCurrency &Diviseur);
    CCurrency CCur,CCur2;
    try
      {
        CCur /= CCur2; ASSERT(false);  //Division d'un CCurrency vide avec un CCurrency vide
      }
    catch (...)
      {
      }
    CCur.Clear();
    CCur2 = 0;
    try
      {
        CCur /= CCur2; ASSERT(false);  //Division d'un CCurrency vide avec un CCurrency à 0
      }
    catch (...)
      {
      }
    CCur.Clear();
    CCur2 = 10;
    CCur /= CCur2; ASSERT(CCur.IsEmpty());  //Division d'un CCurrency vide avec un CCurrency != 0 entier
    CCur.Clear();
    CCur2 = 10.5;
    CCur /= CCur2; ASSERT(CCur.IsEmpty());  //Division d'un CCurrency vide avec un CCurrency != 0 non entier
    CCur = 0;
    CCur2.Clear();
    try
      {
        CCur /= CCur2; ASSERT(false);  //Division d'un CCurrency à 0 avec un CCurrency vide
      }
    catch (...)
      {
      }
    CCur = 0;
    CCur2 = 0;
    try
      {
        CCur /= CCur2; ASSERT(false);  //Division d'un CCurrency à 0 avec un CCurrency à 0
      }
    catch (...)
      {
      }
    CCur = 0;
    CCur2 = 10;
    CCur /= CCur2; ASSERT(CCur == 0);  //Division d'un CCurrency à 0 avec un CCurrency != 0 entier
    CCur = 0;
    CCur2 = 10.5;
    CCur /= CCur2; ASSERT(CCur == 0);  //Division d'un CCurrency à 0 avec un CCurrency != 0 non entier
    CCur = 10;
    CCur2.Clear();
    try
      {
        CCur /= CCur2; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un CCurrency vide
      }
    catch (...)
      {
      }
    CCur = 10;
    CCur2 = 0;
    try
      {
        CCur /= CCur2; ASSERT(false);  //Division d'un CCurrency != 0 entier avec un CCurrency à 0
      }
    catch (...)
      {
      }
    CCur = 10;
    CCur2 = 10;
    CCur /= CCur2; ASSERT(CCur == 1);  //Division d'un CCurrency != 0 entier avec un CCurrency != 0 entier
    CCur = 10;
    CCur2 = 10.5;
    CCur /= CCur2; ASSERT(CCur == 0.9523);  //Division d'un CCurrency != 0 entier avec un CCurrency != 0 non entier
    CCur = 10.5;
    CCur2.Clear();
    try
      {
        CCur /= CCur2; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un CCurrency vide
      }
    catch (...)
      {
      }
    CCur = 10.5;
    CCur2 = 0;
    try
      {
        CCur /= CCur2; ASSERT(false);  //Division d'un CCurrency != 0 non entier avec un CCurrency à 0
      }
    catch (...)
      {
      }
    CCur = 10.5;
    CCur2 = 10;
    CCur /= CCur2; ASSERT(CCur == 1.05);  //Division d'un CCurrency != 0 non entier avec un CCurrency != 0 entier
    CCur = 10.5;
    CCur2 = 10.5;
    CCur /= CCur2; ASSERT(CCur == 1);  //Division d'un CCurrency != 0 non entier avec un CCurrency != 0 non entier
  }
}



